What is a Nested Class in Java?

A nested class is a class declared inside another class. Java allows you to logically group classes that are only used in one place, which helps in improving code readability and encapsulation.

Types of Nested Classes in Java

1. Non-static (Inner) Class
2. Static Nested Class
3. Local Inner Class (inside a method)
4. Anonymous Inner Class (inline class for one-time use)

Non-static Inner Class

• Has access to all members (even private) of the outer class.
• Needs an object of the outer class to be instantiated.

class Outer {
    int outerData = 10;

    class Inner {
        void display() {
            System.out.println("Accessing outer data: " + outerData);
        }
    }
}

public class InnerClassExample {
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();  // Create inner class object
        inner.display();  // Output: Accessing outer data: 10
    }
}

Static Nested Class

• Can only access static members of the outer class.
• Does not require outer class object to be instantiated.

class Outer {
    static int data = 50;

    static class Nested {
        void show() {
            System.out.println("Static data: " + data);
        }
    }
}

public class StaticNestedExample {
    public static void main(String[] args) {
        Outer.Nested obj = new Outer.Nested();  // No outer object needed
        obj.show();  // Output: Static data: 50
    }
}

Local Inner Class (inside a method)

• Declared inside a method.
• Can access final or effectively final variables of the method.

class Outer {
    void outerMethod() {
        int number = 100;  // effectively final

        class LocalInner {
            void print() {
                System.out.println("Local inner class: " + number);
            }
        }

        LocalInner obj = new LocalInner();
        obj.print();
    }
}

public class LocalInnerExample {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.outerMethod();  // Output: Local inner class: 100
    }
}

Anonymous Inner Class

• Used to override methods of a class or interface on the fly.
• Has no name.
• Mostly used with event handling or in multithreading.

abstract class Animal {
    abstract void sound();
}

public class AnonymousInnerExample {
    public static void main(String[] args) {
        Animal obj = new Animal() {
            void sound() {
                System.out.println("Anonymous Inner Class: Dog barks");
            }
        };

        obj.sound();  // Output: Anonymous Inner Class: Dog barks
    }
}

Summary Table