Nested Classes in Java

Java is a widely used programming language, known for its object-oriented principles and versatility. Among its powerful features, nested classes in Java provide a mechanism to define one class within another, which can simplify code organization and improve encapsulation. In this detailed guide, we’ll explore everything about nested classes, including types, examples, practical use cases, and best practices.

What are Nested Classes in Java?

A nested class is a class declared within the scope of another class. They allow you to logically group classes that are only used in one place, increase encapsulation, and make code more readable.

• Encapsulation: Keep classes hidden from the outside world if they are only used internally.
• Logical grouping: Organize classes that belong together.
• Enhanced readability: Makes code cleaner and easier to manage.
• Access to outer class members: Certain nested classes can access private members of the enclosing class.

Types of Nested Classes in Java

Java supports two main types of nested classes:

1. Static Nested Classes
2. Non-Static (Inner) Classes

1. Static Nested Classes

A static nested class is a nested class declared with the static keyword. It does not have access to instance variables of the outer class directly. Instead, it can only access static members of the outer class.

📄

public class OuterClass {
    static int outerStaticVar = 10;

    static class StaticNested {
        void display() {
            System.out.println("Static variable from OuterClass: " + outerStaticVar);
        }
    }

    public static void main(String[] args) {
        OuterClass.StaticNested nestedObj = new OuterClass.StaticNested();
        nestedObj.display();
    }
}

2. Non-Static Nested Classes (Inner Classes)

Inner classes are non-static classes defined inside another class. They can access both static and non-static members of the outer class.

Member Inner Class Example

📄

public class OuterClass {
    private String message = "Hello from OuterClass";

    class InnerClass {
        void showMessage() {
            System.out.println(message);
        }
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner = outer.new InnerClass();
        inner.showMessage();
    }
}

Method-Local Inner Class Example

📄

public class OuterClass {
    void display() {
        class MethodInner {
            void show() {
                System.out.println("Hello from MethodInner class");
            }
        }
        MethodInner mi = new MethodInner();
        mi.show();
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        outer.display();
    }
}

Anonymous Inner Class Example

📄

interface Greeting {
    void sayHello();
}

public class OuterClass {
    public static void main(String[] args) {
        Greeting greeting = new Greeting() {
            public void sayHello() {
                System.out.println("Hello from Anonymous Inner Class!");
            }
        };
        greeting.sayHello();
    }
}

Real-World Use Cases of Nested Classes

• Encapsulating Helper Classes: Private utility classes inside a main class.
• Implementing Event Listeners in GUIs: Anonymous inner classes for button clicks in Swing or JavaFX.
• Data Structures: Inner classes for Node in LinkedList, Tree, or Graph.
• Builder Pattern: Static nested classes are used in the builder pattern for immutable objects.

Example: Inner Class for Node in a LinkedList

Java Inner Class for Node in LinkedList Example

In Java, linked lists are commonly implemented using an inner class for the Node. The inner class allows direct access to the outer class members and helps encapsulate the structure of the list. Below is a detailed example:

LinkedList with Inner Node Class

📄

public class LinkedList {
    private Node head;

    // Inner class Node
    class Node {
        int data;
        Node next;

        Node(int data) {
            this.data = data;
            this.next = null;
        }
    }

    // Method to add a new node at the beginning
    void add(int data) {
        Node newNode = new Node(data);
        newNode.next = head;
        head = newNode;
    }

    // Method to print the linked list
    void printList() {
        Node temp = head;
        while (temp != null) {
            System.out.print(temp.data + " -> ");
            temp = temp.next;
        }
        System.out.println("null");
    }

    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.add(10);
        list.add(20);
        list.add(30);
        list.printList();
    }
}

Explanation

• Inner Class Node: Defined within the LinkedList class, it encapsulates the structure of each node.
• Data and Next: Each node stores an integer value and a reference to the next node.
• Add Method: Creates a new Node and sets it as the new head of the list.
• PrintList Method: Traverses the list and prints all node values.
• Encapsulation: The Node class is only used internally, improving code readability and organization.

Output

Running the above code produces the following output:

📄

30 -> 20 -> 10 -> null

📄

public class LinkedList {
    private Node head;

    class Node {
        int data;
        Node next;

        Node(int data) {
            this.data = data;
            this.next = null;
        }
    }

    void add(int data) {
        Node newNode = new Node(data);
        newNode.next = head;
        head = newNode;
    }

    void printList() {
        Node temp = head;
        while (temp != null) {
            System.out.print(temp.data + " -> ");
            temp = temp.next;
        }
        System.out.println("null");
    }

    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.add(10);
        list.add(20);
        list.add(30);
        list.printList();
    }
}

Best Practices for Using Nested Classes in Java

• Use static nested classes when the inner class does not need to access instance members.
• Use inner classes when the inner class needs access to instance members of the outer class.
• Avoid overly deep nesting; it can reduce code readability.
• Use anonymous inner classes for one-time implementations, especially in event-driven programming.

Comparison Table: Static Nested vs Inner Classes

Frequently Asked Questions (FAQs)

1. What is the difference between a static nested class and an inner class in Java?

A static nested class can only access static members of the outer class and does not require an instance of the outer class. An inner class (non-static) can access both instance and static members and requires an instance of the outer class to be created.

2. Can a nested class be private in Java?

Yes, nested classes can have access modifiers like private, protected, or public. Private nested classes are only accessible within the outer class, enhancing encapsulation.

3. When should I use an anonymous inner class?

Use anonymous inner classes when you need to implement an interface or extend a class only once, such as event handling in GUI applications.

4. Does a nested class increase memory usage?

Inner classes hold a reference to the outer class instance, so they slightly increase memory usage. Static nested classes do not have this overhead and are more memory-efficient.

5. Can nested classes access private members of the outer class?

Yes, inner classes (non-static) can access private members of the outer class directly. Static nested classes cannot access instance variables but can access static members.

Conclusion

Nested classes in Java are powerful tools that help organize code, improve encapsulation, and enhance readability. By understanding the different types—static nested classes, member inner classes, method-local inner classes, and anonymous inner classes—you can use them effectively in real-world applications. Proper usage leads to cleaner, maintainable, and well-structured Java code.