Introduction to Advanced Java

9.1 Introduction to Advanced Java

9.1.1 Explanation

Advanced Java encompasses the concepts and tools that extend beyond basic programming — enabling enterprise-level development, modular system design, and efficient resource management.
In this module, you’ll explore advanced topics including Generics, File I/O, Serialization, Java NIO, and the latest modern features introduced in Java 21 and 2025 standards.

These topics form the backbone of modern enterprise applications, distributed systems, and API frameworks.
Java’s continuous evolution brings new constructs such as Records, Pattern Matching, Virtual Threads, and Sealed Classes, ensuring scalability, security, and developer productivity.

Understanding these advanced mechanisms allows developers to write cleaner, faster, and safer applications adaptable to both traditional and cloud-native environments.

9.2 Generics

9.2.1 Explanation

Generics were introduced in Java 5 to enable type-safe, reusable, and flexible code. They allow classes, interfaces, and methods to operate on different data types while maintaining compile-time type checking.

Before generics, typecasting was required to handle multiple data types in a collection, leading to runtime errors.
Generics eliminate this by enforcing type constraints at compile-time.

Syntax:

ClassName<Type>

Generics improve code reusability (e.g., same class for Integer, String), readability, and safety.
They are widely used in the Collections Framework and for designing APIs and libraries that are flexible yet type-secure.

9.2.2 Code

import java.util.*;

public class GenericExample {

public static <T> void displayList(List<T> list) {

for (T element : list)

System.out.println(element);

}

public static void main(String[] args) {

List<Integer> numbers = Arrays.asList(10, 20, 30);

List<String> words = Arrays.asList("Java", "Generics", "2025");

System.out.println("Integer List:");

displayList(numbers);

System.out.println("\nString List:");

displayList(words);

}

}

9.2.3 Example

Output:

Integer List:

10

20

30

String List:

Java

Generics

2025

Explanation:
The generic method <T> can accept a list of any type.
It ensures compile-time safety by guaranteeing that all elements within a list belong to the same type, eliminating the need for typecasting.

9.2.4 Use Cases

• Designing reusable libraries and APIs.
  

• Implementing custom data structures (Stacks, Queues).
  

• Type-safe Collections Framework usage.
  

• Creating flexible utility functions for data operations.

   

9.2.5 Relevant Table

9.3 File Handling and Java I/O

9.3.1 Explanation

File handling is a crucial part of Java’s standard library, used to read, write, and manipulate files on disk.
The Java I/O API (java.io package) provides stream-based input/output using classes like FileReader, FileWriter, BufferedReader, and PrintWriter.
It follows the principle of stream abstraction, where data flows as a sequence of bytes or characters.

Java distinguishes between:

• Byte Streams – handle binary data (FileInputStream, FileOutputStream).
  
• Character Streams – handle text data (FileReader, FileWriter).
  

Java also introduced NIO (New I/O) in Java 7, enhancing performance with non-blocking I/O and the Path, Files, and Channels APIs for faster file operations.

9.3.2 Code

import java.io.*;

public class FileReadWrite {

public static void main(String[] args) {

String filename = "example.txt";

try (BufferedWriter writer = new BufferedWriter(new FileWriter(filename))) {

writer.write("Welcome to Java 2025!");

writer.newLine();

writer.write("File Handling Example");

} catch (IOException e) {

System.out.println("Error writing to file: " + e.getMessage());

}

try (BufferedReader reader = new BufferedReader(new FileReader(filename))) {

String line;

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

System.out.println(line);

} catch (IOException e) {

System.out.println("Error reading file: " + e.getMessage());

}

}

}

9.3.3 Example

Output:

Welcome to Java 2025!

File Handling Example

Explanation:
The program writes two lines into a text file and reads them back.
The use of try-with-resources ensures that file streams close automatically, preventing memory leaks and resource locking.

9.3.4 Use Cases

• Logging, configuration, and report generation.
  
• Data persistence for lightweight applications.
  
• Reading structured input files (CSV, JSON, XML).
  
• Implementing import/export features in software systems.
  

9.3.5 Relevant Table

9.4 Modern Java Features (Java 21 and 2025)

9.4.1 Explanation

Modern Java (versions 17–21 and upcoming 2025 release) introduces features that make the language more concise, expressive, and performance-optimized. These improvements align Java with modern development paradigms like functional design, lightweight concurrency, and pattern-based type handling.

Key Modern Features:

1. Records — concise syntax for immutable data carriers.
   
2. Pattern Matching for instanceof and switch — simplifies type checks.
   
3. Sealed Classes — restrict inheritance for better security.
   
4. Virtual Threads (Project Loom) — lightweight concurrency for scalable systems.
   
5. Text Blocks & Enhanced Switch Expressions — cleaner multi-line strings and functional switch logic.
   

These innovations redefine Java’s productivity and maintainability, solidifying it as a forward-looking language ready for enterprise and cloud-native computing.

9.4.2 Code

public class ModernJava {

// Record declaration (immutable data class)

record Employee(String name, int age) {}

public static void main(String[] args) {

// Using Records

Employee emp = new Employee("Alice", 30);

System.out.println(emp.name() + " - " + emp.age());

// Pattern Matching

Object obj = "Java 2025";

if (obj instanceof String s)

System.out.println("String detected: " + s.toUpperCase());

// Enhanced Switch

int day = 3;

String result = switch (day) {

case 1, 2, 3 -> "Midweek";

case 4, 5 -> "Weekend Approaching";

default -> "Weekend";

};

System.out.println(result);

}

}

9.4.3 Example

Output:

Alice - 30

String detected: JAVA 2025

Midweek

Explanation:
The program showcases Records for concise class creation, Pattern Matching for simplified type handling, and Enhanced Switch for readable decision logic.
Together, they demonstrate how modern Java reduces boilerplate and improves developer efficiency.

9.4.4 Use Cases

• Representing immutable data (DTOs, API responses).
  
• Writing expressive, readable control flows.
  
• Scalable concurrent web applications using Virtual Threads.
  
• Improving code security through sealed hierarchies.
  

9.4.5 Relevant Table