Advanced Object-Oriented Programming in Java

This part covers advanced OOP concepts in Java including inheritance, polymorphism, interfaces, abstract classes, and their practical applications for developers.

1. Inheritance & Polymorphism

• Inheritance allows classes to inherit properties and methods from parent classes
• Polymorphism allows objects to take multiple forms
• Types of polymorphism: Compile-time (method overloading), Runtime (method overriding)

class Animal {

    void sound() { System.out.println("Animal sound"); }

}

class Dog extends Animal {

    void sound() { System.out.println("Dog barks"); }

}

public class Test {

    public static void main(String[] args) {

        Animal a = new Dog();

        a.sound(); // Outputs: Dog barks

    }

}

2. Interfaces & Abstract Classes

• Interfaces define contracts that implementing classes must follow
• Abstract classes can have both abstract and concrete methods
• Use interfaces for multiple inheritance and abstraction

interface Vehicle {

    void start();

}

abstract class Car implements Vehicle {

    abstract void fuelType();

}

class Sedan extends Car {

    void start() { System.out.println("Car started"); }

    void fuelType() { System.out.println("Petrol"); }

}

3. Collections Framework

• Core interfaces: List, Set, Map, Queue
• Implementations: ArrayList, HashSet, HashMap, LinkedList
• Use generics for type safety

import java.util.*;

List fruits = new ArrayList<>();

fruits.add("Apple");

fruits.add("Banana");

Map ageMap = new HashMap<>();

ageMap.put("John", 25);

ageMap.put("Alice", 30);

4. Generics

• Generics allow classes, interfaces, and methods to operate on objects of various types while providing compile-time type safety

class Box {

    private T item;

    public void set(T item) { this.item = item; }

    public T get() { return item; }

}

Box stringBox = new Box<>();

stringBox.set("Hello");

System.out.println(stringBox.get());

5. Exception Handling

• Checked and unchecked exceptions
• Use try-catch-finally blocks for safe code execution
• Create custom exceptions

try {

    int result = 10 / 0;

} catch (ArithmeticException e) {

    System.out.println("Cannot divide by zero: " + e.getMessage());

} finally {

    System.out.println("Execution completed");

}

Diagram showing Java Collections Framework structure and hierarchy.

Multithreading, File I/O, JDBC & Lambda Expressions

This part explores advanced Java concepts including multithreading, file input/output operations, JDBC for database connectivity, and lambda expressions for functional programming.

1. Multithreading

• Multithreading allows concurrent execution of two or more threads
• Improves performance in CPU-intensive and I/O-bound tasks
• Key methods: start(), run(), sleep(), join()

class MyThread extends Thread {

    public void run() {

        for(int i=0; i<5; i++) {

            System.out.println("Thread: " + i);

        }

    }

}

public class TestThread {

    public static void main(String[] args) {

        MyThread t1 = new MyThread();

        t1.start();

    }

}

2. File Input/Output (I/O)

• Java provides classes in java.io and java.nio for file handling
• Read and write text or binary files safely

import java.io.*;

try {

    BufferedWriter writer = new BufferedWriter(new FileWriter("example.txt"));

    writer.write("Hello Java File I/O!");

    writer.close();

    BufferedReader reader = new BufferedReader(new FileReader("example.txt"));

    String line;

    while((line = reader.readLine()) != null) {

        System.out.println(line);

    }

    reader.close();

} catch(IOException e) {

    e.printStackTrace();

}

3. JDBC (Java Database Connectivity)

• JDBC allows Java applications to connect and interact with relational databases
• Core steps: Load driver, establish connection, create statement, execute queries, process results, close connection

import java.sql.*;

try {

    Class.forName("com.mysql.cj.jdbc.Driver");

    Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/testdb","user","password");

    Statement stmt = conn.createStatement();

    ResultSet rs = stmt.executeQuery("SELECT * FROM Employee");

    while(rs.next()) {

        System.out.println(rs.getInt("EmpID") + " " + rs.getString("Name"));

    }

    conn.close();

} catch(Exception e) {

    e.printStackTrace();

}

4. Lambda Expressions

• Introduced in Java 8 for functional programming
• Simplifies code for interfaces with a single abstract method (functional interfaces)
• Example with List operations:

import java.util.*;

List names = Arrays.asList("John", "Alice", "Bob");

names.forEach(name -> System.out.println("Hello " + name));

Diagram illustrating multithreading execution in Java.

JavaFX, GUI Development, Event Handling & Advanced Topics

This part covers GUI development in Java using JavaFX, event handling, and other advanced Java topics for professional application development.

1. Introduction to JavaFX

• JavaFX is a framework for building rich client applications with Java
• Provides controls like buttons, labels, tables, charts, and layout panes
• Supports CSS styling and FXML for designing UI

import javafx.application.Application;

import javafx.scene.Scene;

import javafx.scene.control.Button;

import javafx.scene.layout.StackPane;

import javafx.stage.Stage;

public class HelloJavaFX extends Application {

    public void start(Stage primaryStage) {

        Button btn = new Button("Click Me");

        btn.setOnAction(e -> System.out.println("Button Clicked!"));

        StackPane root = new StackPane();

        root.getChildren().add(btn);

        Scene scene = new Scene(root, 300, 200);

        primaryStage.setScene(scene);

        primaryStage.setTitle("JavaFX Example");

        primaryStage.show();

    }

    public static void main(String[] args) {

        launch(args);

    }

}

2. Event Handling

• Event-driven programming allows applications to respond to user actions
• Types of events: Mouse events, Key events, Window events
• Use listeners like EventHandler to handle events

btn.setOnAction(new EventHandler<ActionEvent>() {

    @Override

    public void handle(ActionEvent event) {

        System.out.println("Button Clicked!");

    }

});

3. Layouts and Controls

• Common layout panes: StackPane, BorderPane, GridPane, VBox, HBox
• Controls include Button, Label, TextField, ListView, TableView
• Use CSS or FXML to style and structure your GUI efficiently

4. Advanced Topics Overview

• Java Reflection: Inspect classes, methods, and fields at runtime
• Annotations: Custom and built-in annotations for metadata
• Concurrency utilities: ExecutorService, Callable, Future for advanced threading
• Java Modules (JPMS): Organize large applications into modules

Example of JavaFX GUI with button and event handling.

Design Patterns, Logging, Testing & Advanced Practices

This part covers essential advanced Java practices including design patterns, logging frameworks, unit testing, and other best practices for professional development.

1. Design Patterns in Java

• Design patterns provide reusable solutions for common programming problems
• Types of patterns: Creational (Singleton, Factory), Structural (Adapter, Decorator), Behavioral (Observer, Strategy)
• Example: Singleton Pattern

public class Singleton {

    private static Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {

        if(instance == null) {

            instance = new Singleton();

        }

        return instance;

    }

}

2. Logging

• Logging helps track application behavior and debug issues
• Common frameworks: Java Util Logging, Log4j, SLF4J
• Example using Java Util Logging:

import java.util.logging.*;

Logger logger = Logger.getLogger("MyLogger");

logger.info("Application started");

logger.warning("This is a warning message");

logger.severe("This is a severe message");

3. Unit Testing

• Unit testing ensures code works as expected
• Popular frameworks: JUnit, TestNG
• Example using JUnit 5:

import static org.junit.jupiter.api.Assertions.*;

import org.junit.jupiter.api.Test;

public class CalculatorTest {

    @Test

    void testAdd() {

        Calculator calc = new Calculator();

        assertEquals(5, calc.add(2,3));

    }

}

4. Advanced Practices

• Use code versioning tools like Git for project management
• Follow SOLID principles for maintainable code
• Adopt CI/CD pipelines for automated build and deployment
• Use profiling and monitoring tools to optimize performance

Diagram showing Singleton design pattern implementation in Java.

Java Security, Encryption, and Best Practices

This part covers essential security practices in Java, including encryption, authentication, secure coding, and other best practices to build safe and reliable applications.

1. Java Security Overview

• Java provides built-in security features like sandboxing, access control, and cryptography libraries
• Use Java Security Manager to restrict untrusted code
• Secure applications by validating user input and avoiding unsafe operations

2. Encryption in Java

• Java Cryptography Architecture (JCA) provides APIs for encryption, decryption, and digital signatures
• Symmetric Encryption Example (AES):

import javax.crypto.Cipher;

import javax.crypto.KeyGenerator;

import javax.crypto.SecretKey;

KeyGenerator keyGen = KeyGenerator.getInstance("AES");

SecretKey secretKey = keyGen.generateKey();

Cipher aesCipher = Cipher.getInstance("AES");

aesCipher.init(Cipher.ENCRYPT_MODE, secretKey);

byte[] encrypted = aesCipher.doFinal("Hello World".getBytes());

aesCipher.init(Cipher.DECRYPT_MODE, secretKey);

byte[] decrypted = aesCipher.doFinal(encrypted);

System.out.println(new String(decrypted)); // Outputs: Hello World

3. Authentication and Password Security

• Always store passwords using hashing algorithms like SHA-256 or bcrypt
• Never store plain text passwords
• Use Java libraries like java.security.MessageDigest for hashing

import java.security.MessageDigest;

String password = "myPassword";

MessageDigest md = MessageDigest.getInstance("SHA-256");

byte[] hash = md.digest(password.getBytes());

System.out.println(Arrays.toString(hash));

4. Secure Coding Best Practices

• Validate all user inputs to prevent injection attacks
• Handle exceptions without exposing sensitive data
• Keep third-party libraries up-to-date to avoid vulnerabilities
• Use secure communication protocols like HTTPS and TLS

5. Advanced Practices for Enterprise Applications

• Implement role-based access control for multi-user systems
• Use token-based authentication (JWT) for REST APIs
• Monitor application logs for suspicious activity
• Adopt automated security testing in CI/CD pipelines

Diagram illustrating Java security and encryption practices.

Concurrency Utilities, Executors, Thread Pools & Performance Tuning

This part covers Java concurrency utilities, efficient thread management with Executors, thread pools, and performance tuning for high-performance applications.

1. Introduction to Concurrency Utilities

• Java provides java.util.concurrent package for modern concurrency management
• Includes tools like ExecutorService, ConcurrentHashMap, CountDownLatch, and Semaphore
• Helps write thread-safe, scalable applications

2. Executors and Thread Pools

• Executors manage a pool of threads for efficient execution of concurrent tasks
• Reduces overhead of creating new threads repeatedly
• Example using FixedThreadPool:

import java.util.concurrent.*;

ExecutorService executor = Executors.newFixedThreadPool(5);

for(int i=0; i<10; i++) {

    int taskId = i;

    executor.submit(() -> {

        System.out.println("Executing task " + taskId + " by " + Thread.currentThread().getName());

    });

}

executor.shutdown();

3. Concurrent Collections

• Concurrent collections provide thread-safe alternatives to standard collections
• Examples: ConcurrentHashMap, CopyOnWriteArrayList, BlockingQueue
• Use them to avoid explicit synchronization in multithreaded environments

4. Synchronization and Locks

• Java provides synchronized keyword, ReentrantLock, and ReadWriteLock
• Helps prevent race conditions and ensure data consistency
• Example:

import java.util.concurrent.locks.*;

ReentrantLock lock = new ReentrantLock();

lock.lock();

try {

    // critical section

} finally {

    lock.unlock();

}

5. Performance Tuning

• Minimize context switching by using thread pools
• Use profiling tools to identify bottlenecks
• Optimize memory usage and garbage collection settings
• Reduce synchronized blocks to improve throughput

Diagram illustrating thread pool execution in Java concurrency utilities.

Reactive Programming, CompletableFuture, Advanced Streams & Full Disclaimer/Conclusion

This part covers advanced Java topics including reactive programming, asynchronous programming with CompletableFuture, advanced Streams operations, and concludes with a full disclaimer.

1. Introduction to Reactive Programming

• Reactive programming is a paradigm for asynchronous, event-driven applications
• Java provides frameworks like Project Reactor and RxJava to handle reactive streams
• Helps build scalable applications that handle large volumes of data

import reactor.core.publisher.Flux;

Flux numbers = Flux.just(1, 2, 3, 4, 5);

numbers.map(n -> n * n)

       .subscribe(System.out::println);

2. CompletableFuture

• CompletableFuture allows asynchronous task execution with callbacks
• Helps avoid blocking and improves application responsiveness
• Example:

import java.util.concurrent.*;

CompletableFuture.supplyAsync(() -> {

    return "Hello";

}).thenApply(s -> s + " World")

  .thenAccept(System.out::println);

3. Advanced Streams Operations

• Streams API supports filtering, mapping, grouping, and collecting data efficiently
• Advanced operations include flatMap, reduce, groupingBy, and parallel streams

import java.util.*;

import java.util.stream.*;

List> namesList = Arrays.asList(

    Arrays.asList("Alice", "Bob"),

    Arrays.asList("Charlie", "David")

);

List flatNames = namesList.stream()

    .flatMap(List::stream)

    .collect(Collectors.toList());

System.out.println(flatNames); // Outputs: [Alice, Bob, Charlie, David]

4. Best Practices for Advanced Java

• Use asynchronous and reactive programming for IO-heavy applications
• Always close resources and handle exceptions
• Use logging, monitoring, and profiling to maintain high performance
• Keep dependencies updated and apply security patches regularly

5. Full Disclaimer

This Java tutorial is for educational purposes only. Implement these examples responsibly. The author and publisher are not liable for any misuse, data loss, or errors resulting from these examples.

6. Conclusion

Mastering reactive programming, CompletableFuture, and advanced Streams operations allows developers to build scalable, responsive, and maintainable applications. Following best practices, monitoring performance, and ensuring security are essential for professional-grade Java applications.

Diagram illustrating reactive programming and asynchronous execution in Java.