Chapter 12: Special Class Types

1️⃣ Chapter Overview

In Java, special class types such as static classes, final classes, nested classes, anonymous classes, and records are used to enhance functionality, encapsulation, and readability.
This chapter covers how and when to use these classes effectively.

By the end of this chapter, you will understand:

• Static classes and members
• Final classes and methods
• Nested and inner classes
• Anonymous classes
• Java Records (modern feature)

2️⃣ Key Definitions & Terminology

Static Class / Member
Belongs to the class, not to any specific object.

Final Class
Cannot be extended; prevents inheritance.

Nested Class
A class defined inside another class.

Inner Class
Non-static nested class that has access to outer class members.

Anonymous Class
A class without a name, used for one-time object creation.

Record
A special class introduced in Java 14 to model immutable data objects.

3️⃣ Core Concepts Explained

🔹 Static Class / Member

• Static members are shared among all objects of the class.

class Counter {    static int count = 0;        Counter() {        count++;    }} class TestCounter {    public static void main(String[] args) {        Counter c1 = new Counter();        Counter c2 = new Counter();        System.out.println(Counter.count); // 2    }}

Explanation:

• count is shared among all instances.
• Changes reflect across all objects.

🔹 Final Class & Final Method

final class Utility {    final void show() {        System.out.println(“Utility method”);    }} // class ExtendedUtility extends Utility {} // ❌ Error

Explanation:

• Final class cannot be subclassed.
• Final method cannot be overridden.

Use Cases:

• Security-critical classes
• Immutable utility classes

🔹 Nested and Inner Classes

class Outer {    int data = 10;        class Inner {        void display() {            System.out.println(“Data: ” + data);        }    }} class TestInner {    public static void main(String[] args) {        Outer o = new Outer();        Outer.Inner i = o.new Inner();        i.display(); // Data: 10    }}

Explanation:

• Inner class can access outer class members.
• Static nested classes do not require an instance.

🔹 Anonymous Class

interface Greeting {    void sayHello();} class TestAnonymous {    public static void main(String[] args) {        Greeting g = new Greeting() {            public void sayHello() {                System.out.println(“Hello World”);            }        };        g.sayHello();    }}

Explanation:

• One-time use class
• Useful in GUI event handlers, threads

🔹 Records (Java 14+)

record Student(String name, int rollNo) {} class TestRecord {    public static void main(String[] args) {        Student s = new Student(“Alice”, 101);        System.out.println(s.name() + ” – ” + s.rollNo());    }}

Explanation:

• Records are immutable
• Automatically generate constructor, getters, equals(), hashCode(), and toString()

4️⃣ Illustrations & Concept Diagrams (Text-Based)

Special Class Types Overview

Static Class / Member -> Shared across all objectsFinal Class / Method  -> Cannot be extended or overriddenNested / Inner Class  -> Defined inside another classAnonymous Class       -> No name, one-time useRecord                -> Immutable data holder

5️⃣ Syntax & Coding Structure

• Static members: static int count;
• Final class: final class ClassName {}
• Inner class: class Outer { class Inner {} }
• Anonymous class: new InterfaceOrClass() { … };
• Record: record ClassName(field1, field2) {}

6️⃣ Complete Coding Examples

Example 1: Static Member

class Employee {    static int companyCode = 1001;} class TestEmployee {    public static void main(String[] args) {        System.out.println(Employee.companyCode); // 1001    }}

Example 2: Final Method

class Parent {    final void greet() { System.out.println(“Hello from Parent”); }} class Child extends Parent {    // void greet() {} // ❌ Error: Cannot override final method}

Example 3: Inner Class

class House {    String color = “Blue”;    class Room {        void showColor() { System.out.println(color); }    }} class TestHouse {    public static void main(String[] args) {        House h = new House();        House.Room r = h.new Room();        r.showColor(); // Blue    }}

Example 4: Anonymous Class

Runnable r = new Runnable() {    public void run() {        System.out.println(“Thread running”);    }};new Thread(r).start();

Example 5: Record

record Book(String title, double price) {} class TestBook {    public static void main(String[] args) {        Book b = new Book(“Java Guide”, 299.99);        System.out.println(b.title() + ” – ” + b.price());    }}

7️⃣ Concept Tricks & Shortcuts

• Use static for shared constants and utility methods
• Final for security and immutability
• Inner classes to encapsulate related behavior
• Anonymous classes for one-off implementation
• Records for immutable data objects

8️⃣ Advantages & Disadvantages

✅ Advantages

• Static members reduce memory usage
• Final classes/methods ensure security and stability
• Inner/anonymous classes organize code
• Records simplify immutable objects

❌ Disadvantages

• Too many nested classes reduce readability
• Anonymous classes can be hard to debug
• Final classes cannot be extended
• Records cannot be modified

9️⃣ Common Mistakes & Debugging Tips

❌ Trying to extend final classes
❌ Accessing inner class without outer class instance
❌ Misusing static members for non-shared data
❌ Forgetting to implement abstract methods in anonymous classes

✅ Follow proper rules for each special class type

🔟 Real-World Applications

• Utility classes (Math, Collections) → static/final
• GUI event handlers → anonymous classes
• Immutable data transfer objects → records
• Encapsulated modules → nested/inner classes

1️⃣1️⃣ Important Notes & Best Practices

• Use static only for shared data
• Prefer final classes for immutable utility classes
• Records are ideal for DTOs and simple data models
• Inner classes should represent logical grouping

1️⃣2️⃣ MCQs & Concept Check

MCQ 1:

Which keyword prevents a class from being subclassed?

1. a) static
   b) abstract
   c) final ✅
   d) private

Explanation:
final keyword prevents any class from being extended.

MCQ 2:

Which of the following is immutable by default?

1. a) StringBuilder
   b) Record ✅
   c) Array
   d) Anonymous class

Explanation:
Records are immutable data carriers; fields cannot be modified after initialization.

1️⃣3️⃣ Practice Problems & Exercises

1. Create a final class Constants with static members.
2. Implement an inner class inside Car to represent Engine.
3. Use an anonymous class to implement Runnable
4. Create a record Student with name and roll number.

1️⃣4️⃣ Mini Task / Assignment

Mini Assignment:
Design a Library Book System:

• Record for Book
• Inner class for Author details
• Anonymous class for Notification system
• Static members for library code

Chapter 13: Enums & Object Lifecycle

1️⃣ Chapter Overview

Enums and the object lifecycle are essential features of Java that help in code clarity, type safety, and efficient memory management.
In this chapter, you will learn:

• What enums are and why they are used
• Enum syntax and methods
• How objects are created and destroyed in Java
• Constructor calls, garbage collection, and finalize method
• Practical applications of enums and understanding object lifecycle

2️⃣ Key Definitions & Terminology

Enum (Enumeration)
A special Java type used to define a collection of constants.

Object Lifecycle
The sequence of states an object passes through during its existence in memory.

Constructor
Special method called when an object is created.

Garbage Collection (GC)
Automatic memory management process that removes objects no longer in use.

Finalize Method
A method called before an object is destroyed (deprecated in modern Java).

Heap Memory
Memory area where objects are stored at runtime.

3️⃣ Core Concepts Explained

🔹 What is Enum?

Enums provide:

• Type safety
• Readability
• Prevent invalid values

enum Day {    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY} class TestEnum {    public static void main(String[] args) {        Day today = Day.MONDAY;        System.out.println(“Today is ” + today);    }}

Output:

Today is MONDAY

🔹 Enum Features

• Enums can have constructors, fields, and methods:

enum Size {    SMALL(1), MEDIUM(2), LARGE(3);     private int value;    Size(int value) { this.value = value; }    public int getValue() { return value; }} class TestSize {    public static void main(String[] args) {        System.out.println(Size.MEDIUM.getValue()); // 2    }}

• Enum values are immutable
• Enums can implement interfaces

🔹 Object Lifecycle

Steps:

1. Memory allocation → Object created using new keyword
2. Constructor call → Initializes object state
3. Usage → Access fields and methods
4. No longer referenced → Eligible for Garbage Collection
5. Garbage Collector → Frees memory
6. Finalize → Called before destruction (optional, deprecated)

class Sample {    Sample() { System.out.println(“Object created”); }    protected void finalize() { System.out.println(“Object destroyed”); }} class TestLifecycle {    public static void main(String[] args) {        Sample s = new Sample();        s = null; // Eligible for GC        System.gc(); // Request GC    }}

Output:

Object createdObject destroyed (may vary)

Explanation:

• GC timing is managed by JVM; finalize() may not always be called immediately.

4️⃣ Illustrations & Concept Diagrams (Text-Based)

Enum Example

enum Day { MONDAY, TUESDAY, … SUNDAY } Usage:Day today = Day.MONDAY

Object Lifecycle Diagram

Creation (new) → Constructor → Usage → Eligible for GC → Garbage Collection → Object destroyed

5️⃣ Syntax & Coding Structure

• Enum Declaration: enum EnumName { CONSTANT1, CONSTANT2 }
• Constructor in Enum: EnumName(parameters) { … }
• Object Creation: ClassName obj = new ClassName();
• Finalize Method: protected void finalize() { … }

6️⃣ Complete Coding Examples

Example 1: Simple Enum

enum Color {    RED, GREEN, BLUE} class TestColor {    public static void main(String[] args) {        Color c = Color.RED;        System.out.println(c);    }}

Example 2: Enum with Fields & Methods

enum Planet {    EARTH(5.97), MARS(0.64);     private double mass;    Planet(double m) { mass = m; }    public double getMass() { return mass; }} class TestPlanet {    public static void main(String[] args) {        System.out.println(Planet.EARTH.getMass()); // 5.97    }}

Example 3: Object Lifecycle

class Demo {    Demo() { System.out.println(“Constructor called”); }    protected void finalize() { System.out.println(“Finalize called”); }} class TestDemo {    public static void main(String[] args) {        Demo d1 = new Demo();        d1 = null;        System.gc(); // Request garbage collection    }}

7️⃣ Concept Tricks & Shortcuts

• Use enums for fixed sets of constants
• Enums can replace magic numbers or strings
• Always remember JVM manages GC, do not rely on finalize()
• Use gc() only to request, not guarantee collection

8️⃣ Advantages & Disadvantages

✅ Advantages

• Enums: Type safety, readability, maintainability
• Object lifecycle: Automatic memory management
• Finalize (if used) allows cleanup

❌ Disadvantages

• Enums: Cannot modify values at runtime
• Finalize: Deprecated, not reliable for cleanup
• GC timing is unpredictable

9️⃣ Common Mistakes & Debugging Tips

❌ Using integers or strings instead of enums for fixed options
❌ Relying on finalize() for critical cleanup
❌ Forgetting to nullify objects when memory intensive
❌ Confusing enum constants with variables

✅ Prefer enums over constants
✅ Use try-with-resources or explicit cleanup instead of finalize

🔟 Real-World Applications

• Days of the week, months, states → Enums
• Role-based access control → Enums
• Object lifecycle → memory-efficient AI or data-intensive programs
• Game state management → Enums

1️⃣1️⃣ Important Notes & Best Practices

• Always use enums instead of magic values
• Keep objects reachable only when needed
• Avoid overusing finalize, rely on GC
• Enums can have methods, constructors, and implement interfaces

1️⃣2️⃣ MCQs & Concept Check

MCQ 1:

Which of the following is immutable?

1. a) Enum ✅
   b) Class object
   c) Array
   d) StringBuilder

Explanation:
Enum constants cannot be modified once defined, making them immutable.

MCQ 2:

What is true about Java object lifecycle?

1. a) Programmer must destroy objects manually
   b) JVM handles memory allocation and garbage collection ✅
   c) finalize() always executes immediately
   d) Objects do not require memory

Explanation:
Java manages memory automatically using garbage collection; finalize() is optional and timing is unpredictable.

1️⃣3️⃣ Practice Problems & Exercises

1. Create an enum Direction with values NORTH, SOUTH, EAST, WEST.
2. Create a record StudentRecord and try to mutate a field.
3. Create an object and demonstrate garbage collection by nullifying it.

1️⃣4️⃣ Mini Task / Assignment

Mini Assignment:
Design a Traffic Light System:

• Enum for LightColor (RED, YELLOW, GREEN)
• Method to return action (STOP, READY, GO)
• Create a demo to simulate light change

Chapter 14: Exception Handling & Debugging

1️⃣ Chapter Overview

Exception handling is a critical concept in Java that allows programs to gracefully handle runtime errors and maintain stability.
Debugging complements exception handling by helping developers identify and fix errors efficiently.

By the end of this chapter, you will understand:

• Types of exceptions in Java
• The try-catch-finally mechanism
• Throwing exceptions with throw and throws
• Custom exception creation
• Common debugging techniques

2️⃣ Key Definitions & Terminology

Exception
An event that occurs during program execution that disrupts the normal flow.

Checked Exception
Must be declared or handled at compile-time (e.g., IOException).

Unchecked Exception
Occurs at runtime; handling is optional (e.g., ArithmeticException).

try Block
Code that may generate an exception is placed here.

catch Block
Handles exceptions thrown by the try block.

finally Block
Code that always executes, regardless of exceptions.

throw Keyword
Used to explicitly throw an exception.

throws Keyword
Used in method signature to declare exceptions that may be thrown.

3️⃣ Core Concepts Explained

🔹 Types of Exceptions

1. Checked Exceptions → compile-time
   • FileNotFoundException
   • IOException
2. Unchecked Exceptions → runtime
   • ArithmeticException
   • NullPointerException
   • ArrayIndexOutOfBoundsException

🔹 try-catch-finally Syntax

try {    // code that may throw exception} catch(ExceptionType e) {    // handle exception} finally {    // always executes}

Example:

class TestTryCatch {    public static void main(String[] args) {        try {            int result = 10 / 0;        } catch (ArithmeticException e) {            System.out.println(“Cannot divide by zero”);        } finally {            System.out.println(“Execution complete”);        }    }}

Output:

Cannot divide by zeroExecution complete

🔹 throw & throws

class TestThrow {    static void checkAge(int age) throws Exception {        if(age < 18) throw new Exception(“Age must be 18+”);    }     public static void main(String[] args) {        try {            checkAge(16);        } catch(Exception e) {            System.out.println(e.getMessage());        }    }}

Output:

Age must be 18+

🔹 Custom Exceptions

class MyException extends Exception {    MyException(String msg) { super(msg); }} class TestCustom {    public static void main(String[] args) {        try {            throw new MyException(“Custom error occurred”);        } catch(MyException e) {            System.out.println(e.getMessage());        }    }}

Output:

Custom error occurred

4️⃣ Illustrations & Concept Diagrams (Text-Based)

Exception Flow

Normal Execution      |      vException occurs?      |  Yes | No      |   Try Block      |  Catch Block      |  Finally Block (optional)      |  Resume Execution

5️⃣ Syntax & Coding Structure

• try → contains risky code
• catch(ExceptionType e) → handle specific exception
• finally → optional, always executed
• throw → throw exception
• throws → declare exception in method signature

6️⃣ Complete Coding Examples

Example 1: Multiple Catch Blocks

class TestMultipleCatch {    public static void main(String[] args) {        try {            int[] arr = {1,2,3};            System.out.println(arr[5]);        } catch (ArrayIndexOutOfBoundsException e) {            System.out.println(“Index out of bounds”);        } catch (Exception e) {            System.out.println(“General exception”);        }    }}

Output:

Index out of bounds

Example 2: Nested try-catch

class TestNested {    public static void main(String[] args) {        try {            int a = 10 / 0;            try {                int[] arr = new int[5];                arr[5] = 10;            } catch(ArrayIndexOutOfBoundsException e) {                System.out.println(“Inner catch: Index error”);            }        } catch(ArithmeticException e) {            System.out.println(“Outer catch: Division by zero”);        }    }}

Output:

Outer catch: Division by zero

Example 3: Using finally

class TestFinally {    public static void main(String[] args) {        try {            int a = 10;            int b = 5;            System.out.println(a/b);        } catch(ArithmeticException e) {            System.out.println(“Exception caught”);        } finally {            System.out.println(“Finally block executed”);        }    }}

Output:

2Finally block executed

7️⃣ Concept Tricks & Shortcuts

• Always handle specific exceptions before generic ones
• Use finally for resource cleanup
• try-with-resources for automatic resource management
• Custom exceptions improve code readability

8️⃣ Advantages & Disadvantages

✅ Advantages

• Prevents program crashes
• Improves reliability and robustness
• Enables modular error handling
• Allows clean resource management

❌ Disadvantages

• Overusing try-catch blocks reduces readability
• Can mask the real error if not logged
• Slight runtime overhead

9️⃣ Common Mistakes & Debugging Tips

❌ Catching Exception without specificity
❌ Ignoring exceptions in catch block
❌ Forgetting to close resources
❌ Relying on finally for critical operations

✅ Use logging for debugging
✅ Apply try-with-resources for streams, files

🔟 Real-World Applications

• File I/O handling
• Network communication (Socket exceptions)
• Database transactions (SQLException)
• AI pipelines (handling null, type, or data errors)

1️⃣1️⃣ Important Notes & Best Practices

• Always catch specific exceptions first
• Use custom exceptions for meaningful error messages
• Close resources in finally or use try-with-resources
• Log exceptions for debugging

1️⃣2️⃣ MCQs & Concept Check

MCQ 1:

Which block always executes regardless of exception?

1. a) try
   b) catch
   c) finally ✅
   d) throw

Explanation:
The finally block always executes to perform cleanup, whether an exception occurs or not.

MCQ 2:

What is true about unchecked exceptions?

1. a) Must be handled at compile-time
   b) Occur at runtime ✅
   c) Can never be caught
   d) Are checked by compiler

Explanation:
Unchecked exceptions (RuntimeException and subclasses) occur at runtime; handling is optional.

1️⃣3️⃣ Practice Problems & Exercises

1. Write a program to divide two numbers and handle ArithmeticException.
2. Read a file and handle IOException.
3. Create a custom exception InvalidAgeException and throw it when age < 18.

1️⃣4️⃣ Mini Task / Assignment

Mini Assignment:
Design a Bank Transaction System:

• Handle InsufficientFundsException
• Use multiple catch blocks for ArithmeticException and NullPointerException
• Include finally to close resources like database connections

Chapter 15: Generics & Collections Framework

1️⃣ Chapter Overview

Generics and the Collections Framework are essential features in modern Java for type-safe, efficient, and scalable data management.
In this chapter, you will learn:

• What generics are and why they are used
• Generic classes, methods, and interfaces
• Java Collections Framework: List, Set, Map, Queue
• Iterating and manipulating collections
• Best practices and performance considerations

2️⃣ Key Definitions & Terminology

Generics
A feature that allows you to parameterize types to achieve type safety at compile-time.

Collection
A container that stores multiple objects in a structured way.

List
An ordered collection allowing duplicate elements.

Set
A collection that does not allow duplicates.

Map
Stores key-value pairs; keys are unique.

Queue
A collection that follows FIFO (First In First Out) order.

Iterator
An object used to traverse elements in a collection.

3️⃣ Core Concepts Explained

🔹 Generics

Generic Class

class Box<T> {    private T content;    public void set(T content) { this.content = content; }    public T get() { return content; }} class TestBox {    public static void main(String[] args) {        Box<String> b = new Box<>();        b.set(“Java”);        System.out.println(b.get()); // Java    }}

Explanation:

• T is a type parameter
• Provides type safety without casting

Generic Method

class Util {    public static <T> void print(T data) {        System.out.println(data);    }} class TestUtil {    public static void main(String[] args) {        Util.print(“Hello”);        Util.print(123);    }}

🔹 Collections Framework Overview

1. List (Ordered, Duplicates Allowed)
   • ArrayList → Dynamic array, fast random access
   • LinkedList → Doubly-linked list, fast insertion/deletion
2. Set (No Duplicates)
   • HashSet → Unordered
   • TreeSet → Ordered
   • LinkedHashSet → Insertion order
3. Map (Key-Value Pairs)
   • HashMap → Fast lookup
   • TreeMap → Sorted keys
   • LinkedHashMap → Maintains insertion order
4. Queue
   • PriorityQueue → Priority-based
   • LinkedList → Can act as queue

🔹 Example: List Operations

import java.util.ArrayList; class TestList {    public static void main(String[] args) {        ArrayList<String> fruits = new ArrayList<>();        fruits.add(“Apple”);        fruits.add(“Banana”);        fruits.add(“Apple”); // Duplicate allowed         for(String f : fruits) {            System.out.println(f);        }    }}

Output:

AppleBananaApple

🔹 Example: Set Operations

import java.util.HashSet; class TestSet {    public static void main(String[] args) {        HashSet<String> set = new HashSet<>();        set.add(“Apple”);        set.add(“Banana”);        set.add(“Apple”); // Duplicate ignored         for(String s : set) {            System.out.println(s);        }    }}

Output:

AppleBanana

🔹 Example: Map Operations

import java.util.HashMap; class TestMap {    public static void main(String[] args) {        HashMap<Integer, String> map = new HashMap<>();        map.put(1, “Alice”);        map.put(2, “Bob”);        map.put(1, “Charlie”); // Overwrites previous         for(Integer key : map.keySet()) {            System.out.println(key + ” -> ” + map.get(key));        }    }}

Output:

1 -> Charlie2 -> Bob

🔹 Iterating Collections

import java.util.ArrayList;import java.util.Iterator; class TestIterator {    public static void main(String[] args) {        ArrayList<String> list = new ArrayList<>();        list.add(“Java”);        list.add(“Python”);        list.add(“C++”);         Iterator<String> it = list.iterator();        while(it.hasNext()) {            System.out.println(it.next());        }    }}

4️⃣ Illustrations & Concept Diagrams (Text-Based)

Collections Hierarchy

Collection   |— List (ArrayList, LinkedList)   |— Set  (HashSet, TreeSet, LinkedHashSet)   |— Queue (PriorityQueue, LinkedList)Map   |— HashMap, TreeMap, LinkedHashMap

5️⃣ Syntax & Coding Structure

• Generic Class: class ClassName<T> {}
• Generic Method: public static <T> void method(T param)
• Collections: ArrayList<Type> list = new ArrayList<>();
• Map: HashMap<Key, Value> map = new HashMap<>();
• Iterator: Iterator<Type> it = collection.iterator();

6️⃣ Complete Coding Examples

Example 1: Generic Box Class

class Box<T> {    private T item;    public void set(T item) { this.item = item; }    public T get() { return item; }} class TestBox {    public static void main(String[] args) {        Box<Integer> intBox = new Box<>();        intBox.set(100);        System.out.println(intBox.get()); // 100         Box<String> strBox = new Box<>();        strBox.set(“Hello”);        System.out.println(strBox.get()); // Hello    }}

Example 2: ArrayList Operations

import java.util.ArrayList; class TestArrayList {    public static void main(String[] args) {        ArrayList<String> colors = new ArrayList<>();        colors.add(“Red”);        colors.add(“Green”);        colors.add(“Blue”);         colors.remove(“Green”);        System.out.println(colors); // [Red, Blue]    }}

Example 3: HashMap Operations

import java.util.HashMap; class TestHashMap {    public static void main(String[] args) {        HashMap<Integer, String> map = new HashMap<>();        map.put(1, “One”);        map.put(2, “Two”);        map.put(3, “Three”);         System.out.println(map.get(2)); // Two        map.remove(3);        System.out.println(map); // {1=One, 2=Two}    }}

7️⃣ Concept Tricks & Shortcuts

• Use generics to avoid casting and runtime errors
• Use ArrayList for dynamic arrays
• Use HashSet to remove duplicates quickly
• Use HashMap for key-value fast lookup
• Use Iterator for safe traversal during modification

8️⃣ Advantages & Disadvantages

✅ Advantages

• Type-safe collections
• Easy to read and maintain
• Prebuilt methods for sorting, searching, filtering
• Flexible and scalable for large datasets

❌ Disadvantages

• Slight overhead for generic checks
• Collections can have higher memory footprint
• Incorrect iterator usage may cause exceptions

9️⃣ Common Mistakes & Debugging Tips

❌ Mixing raw types and generics
❌ Forgetting to import java.util package
❌ Modifying collection while iterating without iterator
❌ Using wrong collection type for requirement

✅ Use generics consistently
✅ Always prefer enhanced for loop or iterator for traversal

🔟 Real-World Applications

• Storing and processing user data (Lists)
• Maintaining unique records (Set)
• Lookup tables, caching (Map)
• Task scheduling (Queue)
• AI model data preprocessing

1️⃣1️⃣ Important Notes & Best Practices

• Always use specific collection types instead of raw types
• Use generics for compile-time type safety
• Prefer ArrayList over Vector (legacy)
• Use HashMap unless order matters, then use LinkedHashMap

1️⃣2️⃣ MCQs & Concept Check

MCQ 1:

Which collection allows duplicate elements?

1. a) Set
   b) List ✅
   c) Map
   d) Queue

Explanation:
List allows duplicate elements and maintains insertion order.

MCQ 2:

Which of the following is type-safe at compile-time?

1. a) Raw ArrayList
   b) ArrayList<Integer> ✅
   c) HashMap without generics
   d) Object[]

Explanation:
Generics ensure type safety and avoid casting at runtime.

1️⃣3️⃣ Practice Problems & Exercises

1. Create an ArrayList of student names and print in reverse order.
2. Use HashSet to remove duplicate numbers from an array.
3. Create a HashMap of employee IDs and names. Retrieve a name using an ID.

1️⃣4️⃣ Mini Task / Assignment

Mini Assignment:
Design a Library Management System:

• Use ArrayList to store book names
• Use HashSet to maintain unique authors
• Use HashMap to map book ID to book details
• Implement iteration to print all books

Chapter 16: File Handling & I/O Streams

1️⃣ Chapter Overview

File handling and I/O streams allow Java programs to read from and write to files, interact with external data, and handle input/output efficiently.
In this chapter, you will learn:

• Java File I/O basics
• File class and operations
• Byte streams and character streams
• Buffered streams for performance
• Reading/writing files using modern techniques
• Exception handling with I/O

2️⃣ Key Definitions & Terminology

File
A physical entity on disk that stores data.

File I/O
Input and output operations on files.

Byte Stream
Reads/writes data byte by byte (useful for binary files).

Character Stream
Reads/writes data character by character (useful for text files).

Buffered Stream
Streams that use internal buffer to improve I/O performance.

Reader/Writer
Classes for character input/output.

InputStream/OutputStream
Classes for byte input/output.

3️⃣ Core Concepts Explained

🔹 File Class

• Represents a file or directory in Java.
• Common methods:
  • exists() → Check existence
  • createNewFile() → Create new file
  • delete() → Delete file
  • length() → File size

import java.io.File;import java.io.IOException; class TestFile {    public static void main(String[] args) throws IOException {        File file = new File(“sample.txt”);        if(file.createNewFile()) {            System.out.println(“File created: ” + file.getName());        } else {            System.out.println(“File already exists.”);        }        System.out.println(“File exists? ” + file.exists());        System.out.println(“File length: ” + file.length());    }}

🔹 Byte Streams (InputStream & OutputStream)

• For reading/writing binary files

import java.io.FileOutputStream;import java.io.FileInputStream;import java.io.IOException; class TestByteStream {    public static void main(String[] args) throws IOException {        String data = “Hello Java I/O”;         // Write bytes        FileOutputStream out = new FileOutputStream(“output.txt”);        out.write(data.getBytes());        out.close();         // Read bytes        FileInputStream in = new FileInputStream(“output.txt”);        int ch;        while((ch = in.read()) != -1) {            System.out.print((char) ch);        }        in.close();    }}

Output:

Hello Java I/O

🔹 Character Streams (Reader & Writer)

• For reading/writing text files

import java.io.FileWriter;import java.io.FileReader;import java.io.IOException; class TestCharStream {    public static void main(String[] args) throws IOException {        FileWriter writer = new FileWriter(“text.txt”);        writer.write(“Java File Handling”);        writer.close();         FileReader reader = new FileReader(“text.txt”);        int c;        while((c = reader.read()) != -1) {            System.out.print((char)c);        }        reader.close();    }}

🔹 Buffered Streams

• Improves performance by reducing physical I/O operations

import java.io.BufferedReader;import java.io.FileReader;import java.io.IOException; class TestBuffered {    public static void main(String[] args) throws IOException {        BufferedReader br = new BufferedReader(new FileReader(“text.txt”));        String line;        while((line = br.readLine()) != null) {            System.out.println(line);        }        br.close();    }}

🔹 File Handling Best Practices

• Always close streams using close() or try-with-resources
• Handle exceptions with try-catch
• Use buffered streams for large files
• Avoid hard-coded file paths for portability

4️⃣ Illustrations & Concept Diagrams (Text-Based)

File I/O Flow

Program → FileOutputStream/FileWriter → Disk (Write)Program ← FileInputStream/FileReader ← Disk (Read)Buffered Stream → Improves performance using memory buffer

5️⃣ Syntax & Coding Structure

• Byte Stream: FileOutputStream, FileInputStream
• Character Stream: FileWriter, FileReader
• Buffered: BufferedReader, BufferedWriter
• Use try-with-resources for automatic closing

6️⃣ Complete Coding Examples

Example 1: Write and Read Text File

import java.io.FileWriter;import java.io.FileReader;import java.io.IOException; class FileExample {    public static void main(String[] args) throws IOException {        FileWriter fw = new FileWriter(“demo.txt”);        fw.write(“Java File Handling Example”);        fw.close();         FileReader fr = new FileReader(“demo.txt”);        int c;        while((c = fr.read()) != -1) {            System.out.print((char)c);        }        fr.close();    }}

Output:

Java File Handling Example

Example 2: Using BufferedReader

import java.io.BufferedReader;import java.io.FileReader;import java.io.IOException; class BufferedExample {    public static void main(String[] args) throws IOException {        BufferedReader br = new BufferedReader(new FileReader(“demo.txt”));        String line;        while((line = br.readLine()) != null) {            System.out.println(line);        }        br.close();    }}

Example 3: Exception Handling with File I/O

import java.io.File;import java.io.FileReader;import java.io.IOException; class FileException {    public static void main(String[] args) {        File file = new File(“nofile.txt”);        try {            FileReader fr = new FileReader(file);        } catch(IOException e) {            System.out.println(“File not found: ” + e.getMessage());        }    }}

7️⃣ Concept Tricks & Shortcuts

• Use try-with-resources to auto-close streams
• Prefer BufferedReader/Writer for large text files
• Use separator for cross-platform file paths
• Handle exceptions properly to prevent program crash

8️⃣ Advantages & Disadvantages

✅ Advantages

• Read/write files efficiently
• Handle exceptions gracefully
• Supports both binary and text files
• Buffered streams improve performance

❌ Disadvantages

• File I/O is slower than memory operations
• Improper handling can lead to memory leaks
• Streams must always be closed

9️⃣ Common Mistakes & Debugging Tips

❌ Forgetting to close streams
❌ Reading beyond EOF
❌ Mixing byte and character streams incorrectly
❌ Hard-coded file paths causing platform issues

✅ Always use try-with-resources
✅ Check file existence before reading

🔟 Real-World Applications

• Reading/writing configuration files
• Logging applications
• AI data preprocessing from CSV/Text files
• Storing user data, reports, and export files

1️⃣1️⃣ Important Notes & Best Practices

• Always close streams or use try-with-resources
• Use buffered streams for performance
• Handle exceptions properly
• Avoid absolute file paths for portability

1️⃣2️⃣ MCQs & Concept Check

MCQ 1:

Which class is used to read text line by line?

1. a) FileReader
   b) BufferedReader ✅
   c) FileOutputStream
   d) InputStream

Explanation:
BufferedReader provides the readLine() method to read a file line by line efficiently.

MCQ 2:

Which is byte stream class?

1. a) FileReader
   b) FileWriter
   c) FileInputStream ✅
   d) BufferedReader

Explanation:
FileInputStream reads raw bytes from files, suitable for binary data.

1️⃣3️⃣ Practice Problems & Exercises

1. Create a file txt and write 5 student names.
2. Read the file line by line using BufferedReader.
3. Handle missing file exceptions gracefully.
4. Copy content from one file to another using FileReader/FileWriter.

1️⃣4️⃣ Mini Task / Assignment

Mini Assignment:
Build a Student Grade Tracker:

• Input student names and grades into a file
• Read and display all students with grades
• Handle exceptions for file not found or I/O errors

Chapter 17: Multithreading & Concurrency

1️⃣ Chapter Overview

Multithreading and concurrency allow Java programs to perform multiple tasks simultaneously, improving performance and responsiveness.
In this chapter, you will learn:

• What threads are and how they work
• Creating and managing threads
• Thread lifecycle
• Synchronization and thread safety
• Executors, concurrency utilities, and best practices

2️⃣ Key Definitions & Terminology

Thread
A lightweight unit of execution within a process.

Multithreading
Executing multiple threads simultaneously.

Runnable Interface
Defines a task for a thread to run.

Thread Class
Provides methods to create and control threads.

Thread Lifecycle
States: New → Runnable → Running → Waiting → Terminated

Synchronization
Controlling access to shared resources to prevent data inconsistency.

ExecutorService
High-level API for managing threads and tasks in a thread pool.

3️⃣ Core Concepts Explained

🔹 Creating Threads

1. Extending Thread Class

class MyThread extends Thread {    public void run() {        System.out.println(“Thread running”);    }} class TestThread {    public static void main(String[] args) {        MyThread t1 = new MyThread();        t1.start(); // Calls run() in new thread    }}

2. Implementing Runnable Interface

class MyRunnable implements Runnable {    public void run() {        System.out.println(“Runnable Thread running”);    }} class TestRunnable {    public static void main(String[] args) {        Thread t = new Thread(new MyRunnable());        t.start();    }}

🔹 Thread Lifecycle

1. New → Thread object created
2. Runnable → Ready to run (after start())
3. Running → Executing run()
4. Waiting/Blocked → Paused, waiting for resource
5. Terminated → Execution completed

Diagram:

New → Runnable → Running → Waiting/Blocked → Terminated

🔹 Thread Methods

🔹 Synchronization

class Counter {    int count = 0;     synchronized void increment() {        count++;    }} class TestSync {    public static void main(String[] args) throws InterruptedException {        Counter c = new Counter();         Thread t1 = new Thread(() -> {            for(int i=0;i<1000;i++) c.increment();        });        Thread t2 = new Thread(() -> {            for(int i=0;i<1000;i++) c.increment();        });         t1.start();        t2.start();        t1.join();        t2.join();         System.out.println(“Count: ” + c.count);    }}

Explanation:

• Synchronization prevents race conditions when multiple threads access shared resources.

🔹 Executors and Concurrency Utilities

import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors; class Task implements Runnable {    public void run() { System.out.println(“Task executed by: ” + Thread.currentThread().getName()); }} class TestExecutor {    public static void main(String[] args) {        ExecutorService executor = Executors.newFixedThreadPool(3);         for(int i=0;i<5;i++) {            executor.execute(new Task());        }        executor.shutdown();    }}

Explanation:

• ExecutorService manages thread pools, reducing overhead of creating threads manually.

4️⃣ Illustrations & Concept Diagrams (Text-Based)

Thread Lifecycle

[New] → start() → [Runnable] → scheduler → [Running] → wait/notify → [Terminated]

Multithreading Example

Thread1 → Task1Thread2 → Task2Thread3 → Task3Executed simultaneously

5️⃣ Syntax & Coding Structure

• Extend Thread: class MyThread extends Thread → override run()
• Implement Runnable: class MyTask implements Runnable → implement run()
• Start thread: start()
• Synchronize: synchronized method {}
• Thread pool: ExecutorService executor = Executors.newFixedThreadPool(n);

6️⃣ Complete Coding Examples

Example 1: Simple Thread

class SimpleThread extends Thread {    public void run() {        System.out.println(“Thread is running”);    }} class TestSimpleThread {    public static void main(String[] args) {        SimpleThread t = new SimpleThread();        t.start();    }}

Example 2: Runnable Thread

class MyTask implements Runnable {    public void run() {        System.out.println(“Runnable task executed”);    }} class TestRunnableThread {    public static void main(String[] args) {        Thread t = new Thread(new MyTask());        t.start();    }}

Example 3: Thread Synchronization

class SharedCounter {    private int count = 0;     synchronized void increment() { count++; }    int getCount() { return count; }} class TestSyncCounter {    public static void main(String[] args) throws InterruptedException {        SharedCounter c = new SharedCounter();        Thread t1 = new Thread(() -> { for(int i=0;i<1000;i++) c.increment(); });        Thread t2 = new Thread(() -> { for(int i=0;i<1000;i++) c.increment(); });         t1.start(); t2.start();        t1.join(); t2.join();        System.out.println(“Final Count: ” + c.getCount());    }}

7️⃣ Concept Tricks & Shortcuts

• Use Runnable when extending another class is needed
• Use synchronized to prevent race conditions
• Prefer ExecutorService for thread pool management
• Always use join() to wait for threads before accessing shared data

8️⃣ Advantages & Disadvantages

✅ Advantages

• Parallel task execution improves performance
• Efficient CPU utilization
• Thread pools reduce overhead of creating multiple threads

❌ Disadvantages

• Improper synchronization leads to race conditions
• Deadlocks can occur if threads wait on each other
• Multithreading is harder to debug

9️⃣ Common Mistakes & Debugging Tips

❌ Forgetting to synchronize shared resources
❌ Using run() instead of start()
❌ Deadlocks due to circular waits
❌ Ignoring exceptions in threads

✅ Use synchronized or locks
✅ Use Thread.setName() for easier debugging
✅ Utilize Executors for better management

🔟 Real-World Applications

• Concurrent AI model training
• Background data processing
• Web servers handling multiple requests
• GUI applications for responsive UI
• Parallel simulations and tasks in enterprise apps

1️⃣1️⃣ Important Notes & Best Practices

• Always synchronize shared data
• Prefer ExecutorService over manual thread creation
• Avoid blocking operations in main thread
• Keep thread tasks small and focused

1️⃣2️⃣ MCQs & Concept Check

MCQ 1:

Which method starts a new thread in Java?

1. a) run()
   b) start() ✅
   c) execute()
   d) init()

Explanation:
start() creates a new thread and calls run() internally. Calling run() directly runs the code in the current thread.

MCQ 2:

What is the main purpose of synchronized?

1. a) Start a thread
   b) Pause a thread
   c) Prevent concurrent access to shared resources ✅
   d) Execute thread in background

Explanation:
synchronized ensures that only one thread can access a method or block at a time.

1️⃣3️⃣ Practice Problems & Exercises

1. Create two threads to print numbers 1-10 concurrently.
2. Implement a shared counter with and without synchronization. Observe the difference.
3. Use ExecutorService to execute 5 tasks in a thread pool of size 3.

1️⃣4️⃣ Mini Task / Assignment

Mini Assignment:
Design a Bank Transaction Simulator:

• Two threads representing deposit and withdrawal
• Shared account balance with proper synchronization
• Use ExecutorService to handle multiple transaction tasks

Chapter 18: Lambda Expressions & Stream API

1️⃣ Chapter Overview

Lambda expressions and the Stream API are modern Java features introduced in Java 8 to make code more concise, readable, and functional.
In this chapter, you will learn:

• What lambda expressions are and their syntax
• Functional interfaces
• The Stream API for processing collections efficiently
• Common stream operations: filter, map, reduce, collect
• Best practices for functional programming in Java

2️⃣ Key Definitions & Terminology

Lambda Expression
A concise way to represent an anonymous function with parameters and a body.

Functional Interface
An interface with exactly one abstract method. Lambda expressions implement functional interfaces.

Stream
A sequence of elements supporting functional-style operations.

Intermediate Operations
Operations like filter(), map(), sorted() that produce another stream.

Terminal Operations
Operations like collect(), forEach(), reduce() that produce a result or side-effect.

3️⃣ Core Concepts Explained

🔹 Lambda Expression Syntax

(parameters) -> expression(parameters) -> { statements; }

Example 1: No parameters

() -> System.out.println(“Hello Lambda”);

Example 2: Single parameter

x -> x * x

Example 3: Multiple parameters

(a, b) -> a + b

🔹 Functional Interface Examples

@FunctionalInterfaceinterface MathOperation {    int operation(int a, int b);} class TestLambda {    public static void main(String[] args) {        MathOperation add = (a, b) -> a + b;        System.out.println(add.operation(5, 3)); // 8    }}

Explanation:

• Lambda expression (a, b) -> a + b implements the abstract method of MathOperation.

🔹 Stream API Overview

• Stream is not a data structure; it operates on collections.
• Example: List, Set, Map → Stream → operations

import java.util.*;import java.util.stream.*; class TestStream {    public static void main(String[] args) {        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);         numbers.stream()               .filter(n -> n % 2 == 0)               .forEach(System.out::println);    }}

Output:

24

🔹 Stream Operations

Intermediate Operations (lazy evaluation)

• filter() → filter elements
• map() → transform elements
• sorted() → sort elements

Terminal Operations (trigger execution)

• forEach() → perform action on each element
• collect() → collect into a collection
• reduce() → aggregate elements

List<String> names = Arrays.asList(“Alice”, “Bob”, “Charlie”);List<String> filtered = names.stream()                             .filter(s -> s.startsWith(“A”))                             .collect(Collectors.toList());System.out.println(filtered); // [Alice]

🔹 Combining Lambda & Stream

List<Integer> numbers = Arrays.asList(10, 20, 30, 40, 50); int sum = numbers.stream()                 .filter(n -> n > 20)                 .map(n -> n * 2)                 .reduce(0, Integer::sum); System.out.println(sum); // 240

Explanation:

• Filter numbers > 20 → [30, 40, 50]
• Map to double → [60, 80, 100]
• Reduce sum → 240

4️⃣ Illustrations & Concept Diagrams (Text-Based)

Lambda Expression

(a, b) -> a + b   |       | parameters expression

Stream Pipeline

Collection → Stream → Intermediate Ops → Terminal Op → Result

5️⃣ Syntax & Coding Structure

• Lambda: (parameters) -> expression_or_block
• Functional Interface: @FunctionalInterface interface Name { method(); }
• Stream: stream().filter(…).map(…).collect(…)

6️⃣ Complete Coding Examples

Example 1: Simple Lambda

interface Greeting {    void sayHello();} class TestSimpleLambda {    public static void main(String[] args) {        Greeting g = () -> System.out.println(“Hello, Lambda!”);        g.sayHello();    }}

Example 2: Stream Filter & Map

import java.util.*;import java.util.stream.*; class StreamExample {    public static void main(String[] args) {        List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5);        List<Integer> squared = nums.stream()                                    .map(n -> n * n)                                    .collect(Collectors.toList());        System.out.println(squared); // [1, 4, 9, 16, 25]    }}

Example 3: Reduce Operation

import java.util.*;import java.util.stream.*; class ReduceExample {    public static void main(String[] args) {        List<Integer> nums = Arrays.asList(2, 4, 6);        int sum = nums.stream().reduce(0, Integer::sum);        System.out.println(sum); // 12    }}

7️⃣ Concept Tricks & Shortcuts

• Use method references: out::println
• Stream pipeline = lazy evaluation
• Lambda for single-method interfaces
• Chain multiple intermediate operations efficiently

8️⃣ Advantages & Disadvantages

✅ Advantages

• Concise and readable code
• Functional programming style
• Efficient collection processing
• Parallel streams for concurrency

❌ Disadvantages

• Can be complex for beginners
• Debugging lambda expressions is harder
• Overusing streams may reduce readability

9️⃣ Common Mistakes & Debugging Tips

❌ Using lambda without functional interface
❌ Forgetting terminal operation (collect(), forEach())
❌ Modifying collection while streaming
❌ Using stateful lambda expressions

✅ Always use stateless operations
✅ Use method references for clarity

🔟 Real-World Applications

• Filtering user data in applications
• Sorting and mapping collections
• AI data preprocessing pipelines
• Financial calculations and aggregations

1️⃣1️⃣ Important Notes & Best Practices

• Prefer lambda expressions for single-method interfaces
• Use streams for collection manipulation
• Avoid side effects inside lambda expressions
• Use parallel streams only for CPU-intensive tasks

1️⃣2️⃣ MCQs & Concept Check

MCQ 1:

What type of interface can a lambda expression implement?

1. a) Any interface
   b) Functional interface ✅
   c) Abstract class
   d) Concrete class

Explanation:
Lambda expressions can only implement functional interfaces (one abstract method).

MCQ 2:

Which is a terminal operation in Stream API?

1. a) filter()
   b) map()
   c) collect() ✅
   d) sorted()

Explanation:
collect() terminates the stream pipeline and produces a result.

1️⃣3️⃣ Practice Problems & Exercises

1. Create a list of names and filter those starting with “A” using streams.
2. Use map() to convert a list of integers to their squares.
3. Find the sum of all numbers greater than 10 using reduce().

1️⃣4️⃣ Mini Task / Assignment

Mini Assignment:
Design a Student Score Analyzer:

• List of student scores
• Filter scores > 75
• Map to grade letters (A, B, C)
• Use collect() to store results in a list
• Print all high-scoring students

Chapter 18A: Java in the AI Era – Concepts, Tools, and Opportunities

1️⃣ Chapter Overview

Artificial Intelligence (AI) is transforming software development, and Java developers have unique opportunities in this era.
This chapter helps you understand:

• How AI impacts Java development
• Java’s role compared to other languages like Python
• Tools and frameworks for AI in Java
• Career opportunities and skill roadmap

2️⃣ Key Definitions & Terminology

Artificial Intelligence (AI)
Systems that simulate human intelligence and decision-making.

Machine Learning (ML)
Subset of AI that learns patterns from data.

Deep Learning (DL)
Advanced ML using neural networks.

Large Language Models (LLMs)
AI models trained on massive text corpora for NLP tasks.

Data Pipeline
Series of processes to ingest, process, and deliver data for AI models.

3️⃣ Core Concepts Explained

🔹 What AI Means for Java Developers

• Opportunities: Java can be used for AI backend services, enterprise AI systems, and cloud-based AI pipelines.
• Integration: Java integrates AI models via APIs, SDKs, and microservices.
• Enterprise Ready: Java’s strong ecosystem, stability, and performance make it ideal for AI applications in enterprises.

🔹 Java’s Role in Modern AI Systems

1. Backend Development: Serve AI models through REST APIs.
2. Data Processing: Build pipelines using Java frameworks like Apache Spark or Flink.
3. Enterprise AI: Integrate AI into existing Java-based enterprise apps.
4. AI Orchestration: Manage AI workflows and inference pipelines.

🔹 Java vs Python in AI (Conceptual)

Explanation:

• Python is great for experimentation
• Java excels in production, scalable, and enterprise AI systems

🔹 Where Java is Used in AI Pipelines

AI Pipeline Stages and Java Role:

Diagram (Text-Based):

Data Source → Java Pipeline → AI Model → REST API → Client / Application

🔹 Tools and Frameworks for AI in Java

4️⃣ Career & Skill Roadmap

🔹 Skill Areas for Java + AI

1. Core Java & Advanced Java: OOP, concurrency, JVM tuning.
2. Data Handling: JDBC, data structures, pipelines.
3. Spring Boot & Microservices: For AI deployment.
4. AI Integration: REST APIs to call Python/LLM models or DL4J for Java-native AI.
5. Cloud & DevOps: AWS, GCP, Docker, Kubernetes for AI apps.
6. Observability & Security: Logging, monitoring, and securing AI endpoints.

🔹 Career Opportunities

5️⃣ Advantages & Disadvantages

✅ Advantages

• Strong integration with enterprise systems
• High performance and scalability
• Easy deployment of AI services
• Extensive tooling & monitoring ecosystem

❌ Disadvantages

• Not as many AI libraries as Python
• Slower for experimentation/prototyping
• Requires bridging with Python or other ML frameworks for complex models

6️⃣ Common Mistakes & Tips

❌ Ignoring Python + Java hybrid approach
❌ Building AI models fully in Java without using optimized libraries
❌ Not using microservices for AI deployment
❌ Overlooking monitoring/logging of AI services

✅ Use Java for production & integration
✅ Use Python for research and experimentation
✅ Build scalable AI pipelines
✅ Secure and monitor AI endpoints

7️⃣ Illustrations & Concept Diagrams (Text-Based)

Java in AI Ecosystem

Data → Java Pipeline → AI Model (DL4J / TensorFlow Java) → REST API → Enterprise App / Client

8️⃣ MCQs & Concept Check

MCQ 1:

Which stage in AI pipelines can Java handle efficiently?

1. a) Experimentation only
   b) Deployment & backend integration ✅
   c) Training neural networks from scratch
   d) None of the above

Explanation:
Java excels at deploying AI models and integrating them into production systems.

MCQ 2:

Which Java library is best for deep learning?

1. a) Weka
   b) Deeplearning4j ✅
   c) JDBC
   d) Logback

Explanation:
Deeplearning4j supports neural networks and deep learning in Java.

9️⃣ Practice Exercises

1. Build a Java REST API that calls a pre-trained AI model.
2. Use Deeplearning4j to load and run an inference model in Java.
3. Create a data pipeline in Java to preprocess data for AI models.
4. Compare Java vs Python AI API performance.

🔟 Mini Task / Assignment

Mini Assignment:
Build a Java AI Integration Project:

• REST API backend in Java
• Integrate a simple ML model (Java-native or Python via API)
• Log AI predictions and monitor performance
• Deploy using Docker or Kubernetes

Chapter 19: Java Networking & Sockets

1️⃣ Chapter Overview

Networking in Java allows applications to communicate over a network, such as the Internet or a local network.
Sockets are the core building blocks of Java networking and are widely used in client-server applications, distributed systems, and AI-powered services.

In this chapter, you will learn:

• Basics of computer networking
• Java networking architecture
• Working with IP addresses and URLs
• Socket programming (client & server)
• TCP vs UDP concepts
• Real-world networking use cases

2️⃣ Key Definitions & Terminology

Network
A collection of interconnected computers that share data.

Protocol
A set of rules for communication (e.g., HTTP, TCP/IP).

IP Address
A unique identifier for a device on a network.

Port
A logical endpoint for communication.

Socket
An endpoint for two-way communication between programs.

Client
A program that requests services.

Server
A program that provides services.

3️⃣ Core Concepts Explained

🔹 Java Networking Architecture

Java provides networking support through the java.net package.

Key classes:

• InetAddress
• URL
• URLConnection
• Socket
• ServerSocket
• DatagramSocket

🔹 InetAddress (IP Address Handling)

import java.net.InetAddress; class TestInet {    public static void main(String[] args) throws Exception {        InetAddress ip = InetAddress.getLocalHost();        System.out.println(“Host Name: ” + ip.getHostName());        System.out.println(“IP Address: ” + ip.getHostAddress());    }}

Explanation:

• InetAddress represents an IP address.
• getLocalHost() fetches local machine details.

🔹 Working with URLs

import java.net.URL; class TestURL {    public static void main(String[] args) throws Exception {        URL url = new URL(“https://www.example.com”);        System.out.println(“Protocol: ” + url.getProtocol());        System.out.println(“Host: ” + url.getHost());        System.out.println(“Port: ” + url.getPort());        System.out.println(“File: ” + url.getFile());    }}

Explanation:

• URL class parses web addresses into components.

4️⃣ Socket Programming (Core Concept)

🔹 TCP Socket Communication

Server Program

import java.io.*;import java.net.*; class Server {    public static void main(String[] args) throws IOException {        ServerSocket serverSocket = new ServerSocket(5000);        System.out.println(“Server started. Waiting for client…”);         Socket socket = serverSocket.accept();        DataInputStream in = new DataInputStream(socket.getInputStream());        String message = in.readUTF();        System.out.println(“Client says: ” + message);         serverSocket.close();    }}

Client Program

import java.io.*;import java.net.*; class Client {    public static void main(String[] args) throws IOException {        Socket socket = new Socket(“localhost”, 5000);        DataOutputStream out = new DataOutputStream(socket.getOutputStream());        out.writeUTF(“Hello Server!”);        out.flush();        socket.close();    }}

Explanation:

• Server listens on a port
• Client connects using IP + port
• Data exchanged using streams

5️⃣ UDP Communication (Datagram)

import java.net.*; class UDPExample {    public static void main(String[] args) throws Exception {        DatagramSocket socket = new DatagramSocket();        String msg = “Hello UDP”;        DatagramPacket packet =            new DatagramPacket(msg.getBytes(), msg.length(),                               InetAddress.getLocalHost(), 4000);        socket.send(packet);        socket.close();    }}

Explanation:

• UDP is connectionless and faster
• No guarantee of delivery

6️⃣ Illustrations & Concept Diagrams (Text-Based)

Client–Server Communication

Client → Request → ServerClient ← Response ← Server

TCP vs UDP

TCP: Reliable | Ordered | SlowerUDP: Fast | Unreliable | No connection

7️⃣ Syntax & Coding Structure

• IP Handling: getByName()
• URL: new URL(“http://…”)
• ServerSocket: new ServerSocket(port)
• Socket: new Socket(host, port)
• Streams: InputStream, OutputStream

8️⃣ Advantages & Disadvantages

✅ Advantages

• Enables distributed applications
• Supports client-server architecture
• Essential for web, cloud, and AI systems

❌ Disadvantages

• Network failures must be handled
• Security concerns if not configured properly
• Slower than local method calls

9️⃣ Common Mistakes & Debugging Tips

❌ Forgetting to close sockets
❌ Using wrong port numbers
❌ Blocking calls without timeout
❌ Not handling IOException

✅ Always close sockets in finally
✅ Use proper exception handling
✅ Test server before client

🔟 Real-World Applications

• Chat applications
• Online games
• REST APIs and microservices
• AI model serving over network
• Distributed enterprise systems

1️⃣1️⃣ Important Notes & Best Practices

• Always validate input data
• Use secure protocols (HTTPS)
• Handle timeouts and failures
• Prefer TCP for reliability, UDP for speed

1️⃣2️⃣ MCQs & Concept Check

MCQ 1:

Which class is used to create a server socket?

1. a) Socket
   b) ServerSocket ✅
   c) DatagramSocket
   d) URL

Explanation:
ServerSocket listens for client connections on a specific port.

MCQ 2:

Which protocol is connectionless?

1. a) TCP
   b) HTTP
   c) UDP ✅
   d) FTP

Explanation:
UDP does not establish a connection and does not guarantee delivery.

1️⃣3️⃣ Practice Problems & Exercises

1. Write a client-server program to exchange messages.
2. Display IP address of a given website.
3. Modify socket program to send response from server to client.

1️⃣4️⃣ Mini Task / Assignment

Mini Assignment:
Create a Simple Chat Application:

• One server
• Multiple clients (use threads)
• Exchange text messages
• Handle disconnection gracefully

Chapter 20: JDBC & Database Connectivity

1️⃣ Chapter Overview

JDBC (Java Database Connectivity) enables Java applications to connect, query, and manipulate databases.
It is a core skill for enterprise applications, backend systems, and AI-based data-driven applications.

In this chapter, you will learn:

• What JDBC is and why it is needed
• JDBC architecture and components
• Steps to connect Java with a database
• CRUD operations using JDBC
• PreparedStatement vs Statement
• Best practices for database handling

2️⃣ Key Definitions & Terminology

JDBC
An API that allows Java programs to interact with relational databases.

Driver
A software component that enables Java applications to communicate with databases.

Connection
A session between Java application and database.

Statement
Used to execute SQL queries.

PreparedStatement
A precompiled SQL statement with parameters.

ResultSet
Stores data retrieved from database queries.

CRUD Operations
Create, Read, Update, Delete operations on database records.

3️⃣ Core Concepts Explained

🔹 JDBC Architecture

JDBC follows a driver-based architecture.

Main Components:

1. Java Application
2. JDBC API
3. JDBC Driver
4. Database

Java App → JDBC API → JDBC Driver → Database

🔹 Types of JDBC Drivers

1. Type 1 – JDBC-ODBC Bridge (Deprecated)
2. Type 2 – Native API Driver
3. Type 3 – Network Protocol Driver
4. Type 4 – Thin Driver ✅ (Most used)

4️⃣ Steps to Connect Java with Database

Step 1: Load Driver

Class.forName(“com.mysql.cj.jdbc.Driver”);

Step 2: Establish Connection

Connection con = DriverManager.getConnection(    “jdbc:mysql://localhost:3306/testdb”, “root”, “password”);

Step 3: Create Statement

Statement stmt = con.createStatement();

Step 4: Execute Query

ResultSet rs = stmt.executeQuery(“SELECT * FROM student”);

Step 5: Process Result

while(rs.next()) {    System.out.println(rs.getInt(1) + ” ” + rs.getString(2));}

Step 6: Close Connection

con.close();

5️⃣ Coding Examples (Complete & Explained)

🔹 Example 1: Fetch Records (SELECT)

import java.sql.*; class FetchData {    public static void main(String[] args) {        try {            Class.forName(“com.mysql.cj.jdbc.Driver”);            Connection con = DriverManager.getConnection(                “jdbc:mysql://localhost:3306/testdb”, “root”, “password”);             Statement stmt = con.createStatement();            ResultSet rs = stmt.executeQuery(“SELECT * FROM student”);             while(rs.next()) {                System.out.println(                    rs.getInt(“id”) + ” ” +                    rs.getString(“name”) + ” ” +                    rs.getInt(“marks”)                );            }            con.close();        } catch(Exception e) {            System.out.println(e);        }    }}

Explanation:

• Connects Java to MySQL
• Executes SELECT query
• Reads data using ResultSet

🔹 Example 2: Insert Record (INSERT)

import java.sql.*; class InsertData {    public static void main(String[] args) {        try {            Connection con = DriverManager.getConnection(                “jdbc:mysql://localhost:3306/testdb”, “root”, “password”);             Statement stmt = con.createStatement();            stmt.executeUpdate(                “INSERT INTO student VALUES (1, ‘Amit’, 85)”);             System.out.println(“Record inserted”);            con.close();        } catch(Exception e) {            System.out.println(e);        }    }}

🔹 Example 3: PreparedStatement (Best Practice)

import java.sql.*; class PreparedExample {    public static void main(String[] args) {        try {            Connection con = DriverManager.getConnection(                “jdbc:mysql://localhost:3306/testdb”, “root”, “password”);             PreparedStatement ps =                con.prepareStatement(“INSERT INTO student VALUES (?, ?, ?)”);             ps.setInt(1, 2);            ps.setString(2, “Neha”);            ps.setInt(3, 90);             ps.executeUpdate();            System.out.println(“Record inserted safely”);            con.close();        } catch(Exception e) {            System.out.println(e);        }    }}

Why PreparedStatement is better:

• Prevents SQL Injection
• Faster execution
• More secure

6️⃣ Statement vs PreparedStatement

7️⃣ Illustrations & Concept Diagrams (Text-Based)

JDBC Flow

Load Driver → Create Connection → Execute SQL → Process Result → Close Connection

8️⃣ Advantages & Disadvantages

✅ Advantages

• Platform-independent database access
• Supports multiple databases
• Secure with PreparedStatement

❌ Disadvantages

• Boilerplate code
• Requires database drivers
• Poor resource handling without best practices

9️⃣ Common Mistakes & Debugging Tips

❌ Forgetting to close connection
❌ Hardcoding credentials
❌ Using Statement instead of PreparedStatement
❌ Not handling SQLExceptions

✅ Use try-with-resources
✅ Externalize DB credentials

🔟 Real-World Applications

• Student management systems
• Banking and financial software
• Enterprise backend systems
• AI applications storing training data
• Web applications (Spring + JDBC)

1️⃣1️⃣ Important Notes & Best Practices

• Always use PreparedStatement
• Close resources properly
• Use connection pooling in enterprise apps
• Never expose database credentials

1️⃣2️⃣ MCQs & Concept Check

MCQ 1:

Which interface is used to execute parameterized queries?

1. a) Statement
   b) ResultSet
   c) PreparedStatement ✅
   d) Connection

Explanation:
PreparedStatement allows parameterized SQL queries and prevents SQL injection.

MCQ 2:

Which JDBC driver is most commonly used today?

1. a) Type 1
   b) Type 2
   c) Type 3
   d) Type 4 ✅

Explanation:
Type 4 (Thin Driver) communicates directly with the database using Java.

1️⃣3️⃣ Practice Problems & Exercises

1. Create a table employee and insert records using JDBC.
2. Fetch all records and display them.
3. Update employee salary using PreparedStatement.
4. Delete a record by ID.

1️⃣4️⃣ Mini Task / Assignment

Mini Assignment:
Build a Student Result Management System:

• Insert student data
• Retrieve all records
• Update marks
• Delete records
• Use PreparedStatement for all operations