Inner Classes in Java

Inner classes are classes defined inside another class. They're used for encapsulation, logical grouping, and implementing callbacks/listeners.

Four Types of Inner Classes

%%{init: {'theme': 'base', 'themeVariables': {'fontSize': '13px', 'fontFamily': 'Inter, -apple-system, sans-serif'}, 'flowchart': {'nodeSpacing': 30, 'rankSpacing': 50, 'padding': 12, 'curve': 'basis'}, 'sequence': {'actorMargin': 60, 'messageMargin': 40}, 'class': {'padding': 12}}}%%
flowchart LR
    A(("🏗️ Nested Classes")) --> B[["📦 Static Nested Class"]]
    A --> C{{"🔄 Non-Static Inner Class"}}
    C --> D(["👤 Member Inner Class"])
    C --> E(["📍 Local Inner Class"])
    C --> F(["👻 Anonymous Inner Class"])

    style A fill:#BFDBFE,stroke:#93C5FD,color:#1E40AF
    style B fill:#BFDBFE,stroke:#93C5FD,color:#1E40AF
    style C fill:#DBEAFE,stroke:#93C5FD,color:#1E40AF
    style D fill:#FEF3C7,stroke:#FCD34D,color:#1E40AF
    style E fill:#FCA5A5,stroke:#FCA5A5,color:#1E40AF
    style F fill:#FEE2E2,stroke:#FCA5A5,color:#1E40AF

1. Member Inner Class

Defined inside a class but outside any method. Has access to all outer class members, including private.

public class University {
    private String name = "IIT";

    public class Department {
        public void display() {
            System.out.println("Dept in " + name);  // accesses outer's private field
        }
    }
}

// Creating instance — needs an outer class instance
University uni = new University();
University.Department dept = uni.new Department();
dept.display();  // "Dept in IIT"

Use case: When the inner class logically belongs to the outer class and needs access to its state. Example: HashMap.Node (each Node belongs to the HashMap).

2. Static Nested Class

Declared with static. Does NOT have access to outer class instance members. It's essentially a top-level class scoped inside another.

public class Order {
    private String orderId;

    public static class Builder {
        private String orderId;
        private String item;

        public Builder orderId(String id) { this.orderId = id; return this; }
        public Builder item(String item) { this.item = item; return this; }
        public Order build() {
            Order order = new Order();
            order.orderId = this.orderId;
            return order;
        }
    }
}

// No outer instance needed
Order order = new Order.Builder()
    .orderId("ORD-123")
    .item("Laptop")
    .build();

Use case: Builder pattern, helper classes that don't need outer instance. Example: Map.Entry<K,V> is logically tied to Map but doesn't need a Map instance.

3. Local Inner Class

Defined inside a method. Only accessible within that method.

public class Calculator {
    public void calculate() {
        final int factor = 10;

        class Multiplier {
            int multiply(int x) {
                return x * factor;  // can access effectively final local vars
            }
        }

        Multiplier m = new Multiplier();
        System.out.println(m.multiply(5));  // 50
    }
}

Use case: Rare in modern Java. Lambdas replaced most use cases.

4. Anonymous Inner Class

A class with no name, defined and instantiated at the same time. Used for one-off implementations.

// Before Java 8 — anonymous class for interface implementation
Runnable task = new Runnable() {
    @Override
    public void run() {
        System.out.println("Running");
    }
};

// After Java 8 — lambda replaces this
Runnable task = () -> System.out.println("Running");

When you still need anonymous classes (can't use lambdas)

// When you need to override multiple methods or extend a class
JButton button = new JButton("Click");
button.addMouseListener(new MouseAdapter() {
    @Override
    public void mouseClicked(MouseEvent e) { /* handle click */ }

    @Override
    public void mouseEntered(MouseEvent e) { /* handle hover */ }
});

Lambdas only work for functional interfaces (single abstract method). If you need multiple methods, use anonymous classes.

Comparison Table

Real-World Usage in Java SDK

Interview Questions