Java Inner Classes

An inner class in Java is a class defined inside another class. Unlike a normal top-level class, an inner class is tied to its enclosing class — and, in most cases, to one specific instance of it — which lets it read and modify the enclosing class’s fields and call its methods directly, even the private ones. Inner classes let you group small helper classes together with the class that actually uses them, model tight one-to-many relationships (think of a linked list and its internal node type), and write short, throwaway implementations of an interface without creating a whole new file. Java actually has four distinct kinds of inner class, and knowing which one to reach for is a core part of writing clean, idiomatic Java OOP code.

Overview: How Inner Classes Work

A class nested inside another class is compiled into its own .class file, but at the source level it behaves as a member of the outer class, just like a field or method. There are four categories, and they differ mainly in where they are declared and whether they are tied to an instance of the outer class.

1. Member (Non-Static) Inner Classes

Declared directly inside a class body, without the static keyword. Every object of this kind of inner class is implicitly linked to one instance of the outer class, and it can freely access that instance’s fields and methods — including private ones — without needing a getter.

2. Static Nested Classes

Declared with the static keyword. A static nested class behaves like any other top-level class except that it is namespaced inside the outer class. It does not hold a reference to an outer instance, so it can only access the outer class’s static members directly.

3. Local Inner Classes

Declared inside a method body (or constructor, or even a block). A local class is visible only within that block, and it can capture local variables from the enclosing method — as long as those variables are final or effectively final (never reassigned after initialization).

4. Anonymous Inner Classes

A class with no name, declared and instantiated in a single expression, usually to supply a one-off implementation of an interface or to extend a class on the spot. Anonymous classes are common when working with listeners, comparators, and threads, though in modern Java lambdas often replace them for functional interfaces.

All four kinds can see the members of their enclosing class, and non-static ones can also reference the enclosing instance explicitly using OuterClassName.this, which is useful when a field name in the inner class shadows a field of the same name in the outer class.

Syntax

class Outer {
    // member inner class
    class Inner { }

    // static nested class
    static class Nested { }

    void method() {
        // local inner class
        class Local { }
    }

    void anotherMethod() {
        // anonymous inner class implementing an interface
        Runnable r = new Runnable() {
            public void run() { }
        };
    }
}

Kind	Declared	Keyword	Holds outer reference?	Instantiated as
Member inner class	Inside class body	none	Yes	`outer.new Inner()`
Static nested class	Inside class body	`static`	No	`new Outer.Nested()`
Local class	Inside a method	none	Yes, if method is non-static	`new Local()` inside the method
Anonymous class	Inside an expression	none	Yes, if context is non-static	`new SomeType() { ... }`

Examples

Example 1: Member Inner Class Accessing an Outer Field

public class Main {
    private String brand = "Toyota";

    class Engine {
        void start() {
            System.out.println("Starting engine of " + brand);
        }
    }

    public static void main(String[] args) {
        Main car = new Main();
        Main.Engine engine = car.new Engine();
        engine.start();
    }
}

Output:
Starting engine of Toyota

The Engine class has no field of its own for the car’s brand, yet it reads brand straight from the enclosing Main instance. That works because a member inner class object is always created in the context of an outer object — here, car.new Engine() — and the compiler wires up a hidden link back to that specific car.

Example 2: Static Nested Class

public class Main {
    static class Point {
        int x, y;

        Point(int x, int y) {
            this.x = x;
            this.y = y;
        }

        void display() {
            System.out.println("Point(" + x + ", " + y + ")");
        }
    }

    public static void main(String[] args) {
        Point p1 = new Point(3, 4);
        Point p2 = new Point(7, 1);
        p1.display();
        p2.display();
    }
}

Output:
Point(3, 4)
Point(7, 1)

Because Point is static, it does not need an enclosing Main instance at all — inside main, which is itself static, we simply write new Point(3, 4). This is the pattern used all over the standard library, for example Map.Entry.

Example 3: Local Inner Class

public class Main {
    void processOrder(double amount) {
        class Discount {
            double apply() {
                if (amount > 100) {
                    return amount - amount / 10;
                }
                return amount;
            }
        }
        Discount discount = new Discount();
        System.out.println("Final price: " + discount.apply());
    }

    public static void main(String[] args) {
        Main shop = new Main();
        shop.processOrder(150.0);
        shop.processOrder(50.0);
    }
}

Output:
Final price: 135.0
Final price: 50.0

The Discount class only makes sense inside processOrder, so it is declared right there instead of cluttering the class body. It captures the method parameter amount, which is effectively final because it is never reassigned after the method starts.

Example 4: Anonymous Inner Class

import java.util.Arrays;
import java.util.Comparator;

public class Main {
    public static void main(String[] args) {
        String[] names = {"Charlie", "Al", "Bob"};

        Arrays.sort(names, new Comparator() {
            @Override
            public int compare(String a, String b) {
                return Integer.compare(a.length(), b.length());
            }
        });

        System.out.println(Arrays.toString(names));
    }
}

Output:
[Al, Bob, Charlie]

Instead of writing a whole named class that implements Comparator<String>, we supply the implementation inline as an anonymous class, right where Arrays.sort needs it. It is used exactly once, so giving it a name would add nothing but noise.

Under the Hood: What the Compiler Actually Does

Every inner class, of every kind, is compiled into its own .class file named OuterClassName$InnerClassName.class. For Example 1, javac produces both Main.class and Main$Engine.class. Anonymous classes don’t have a real name, so the compiler numbers them in declaration order — Main$1.class, Main$2.class, and so on.

For non-static inner classes (member, local, and anonymous classes created from an instance context), the compiler inserts a synthetic field — visible in decompiled bytecode as this$0 — that stores a reference to the enclosing instance. That field is populated by a hidden constructor parameter, which is exactly what happens behind the scenes when you write car.new Engine() or simply new Engine() from inside an instance method of Main. This hidden reference is why the inner class can read the outer object’s private fields directly: at the bytecode level, it is really calling through this$0.brand. It also means that as long as an inner class instance is reachable, the outer object it points to cannot be garbage collected — a classic source of memory leaks when non-static inner classes (or anonymous listener classes) are stored somewhere long-lived.

Static nested classes get no such field, which is exactly why they cannot access instance members of the outer class and why they don’t keep the outer object alive.

For local and anonymous classes, any local variable they capture from the enclosing method is copied into a synthetic final field of the inner class, set through another hidden constructor parameter. The inner class is working with its own private snapshot of that variable’s value, not a live link back to the method’s stack frame. That is the real reason captured local variables must be final or effectively final: if the method could keep changing the variable after the inner object copied it, the two would silently drift apart, and Java avoids that entire class of bugs by refusing to compile.

Common Mistakes

Mistake 1: Instantiating a Non-Static Inner Class Without an Outer Instance

public class Main {
    class Inner {
    }

    public static void main(String[] args) {
        Inner inner = new Inner();
    }
}

This fails to compile. main is static, so there is no implicit Main instance (this) available to bind the new Inner object to — every non-static inner class instance needs an outer instance to attach to.

public class Main {
    class Inner {
    }

    public static void main(String[] args) {
        Main outer = new Main();
        Main.Inner inner = outer.new Inner();
        System.out.println("Inner instance created");
    }
}

Output:
Inner instance created

Creating an explicit Main object first and using outer.new Inner() gives the compiler an outer instance to wire the hidden reference to, so it compiles and runs correctly.

Mistake 2: Mutating a Local Variable Captured by an Inner Class

import java.util.function.Supplier;

public class Main {
    public static void main(String[] args) {
        int counter = 0;
        Supplier supplier = new Supplier() {
            @Override
            public Integer get() {
                return counter;
            }
        };
        counter++;
        System.out.println(supplier.get());
    }
}

This fails to compile with “local variables referenced from an inner class must be final or effectively final”, because counter++ reassigns counter somewhere in the method, which disqualifies it as effectively final — even though the reassignment happens after the anonymous class is created.

import java.util.function.Supplier;
import java.util.concurrent.atomic.AtomicInteger;

public class Main {
    public static void main(String[] args) {
        AtomicInteger counter = new AtomicInteger(0);
        Supplier supplier = new Supplier() {
            @Override
            public Integer get() {
                return counter.get();
            }
        };
        counter.incrementAndGet();
        System.out.println(supplier.get());
    }
}

Output:
1

Wrapping the mutable state in an AtomicInteger keeps the reference itself effectively final while still allowing the underlying value to change — the inner class captures the reference, not a frozen snapshot of a primitive, so it always sees the latest value.

Best Practices

Prefer a static nested class whenever the inner class does not need access to the outer instance — it avoids the hidden outer reference entirely and removes a potential memory-leak risk.
Use local or anonymous inner classes for short, single-use logic; if the same logic is needed in more than one place, promote it to a proper top-level or static nested class.
In Java 8 and later, prefer a lambda expression over an anonymous inner class when implementing a functional interface (an interface with a single abstract method) — it is shorter and does not create an extra class file or outer reference.
Keep inner classes small and focused; if one grows complex or needs to be unit-tested on its own, it usually deserves to become a regular top-level class.
Be careful with non-static inner classes stored in long-lived containers, such as listeners registered on a static field — they can keep the enclosing instance alive far longer than intended.
Use OuterClassName.this.fieldName to explicitly reach an outer field when an inner class field or parameter shadows it.

Practice Exercises

Write a class BankAccount with a private double balance field and a non-static inner class Statement that has a method printBalance() printing the current balance. Deposit some money, then create a Statement from main and call printBalance() to confirm it sees the updated value.
Rewrite Example 4’s anonymous Comparator as a lambda expression instead, and confirm Arrays.sort still produces [Al, Bob, Charlie].
Write a class Library containing a static nested class Book (with title and author fields plus a constructor), a method that builds and returns an array of a few Book objects, and a main method that prints each book’s title and author.

Summary

Java has four kinds of inner classes: member (non-static), static nested, local, and anonymous.
Non-static inner classes hold an implicit reference to an instance of the outer class and can access its private members directly.
Static nested classes behave like ordinary top-level classes but are namespaced inside the outer class, and cannot access the outer instance’s members.
Local classes live inside a method body; anonymous classes are declared and instantiated in a single expression, typically to supply a one-off interface implementation.
The compiler generates a separate .class file for every inner class, named OuterName$InnerName.class (or numbered for anonymous classes), and adds a hidden outer-instance reference to non-static ones.
Captured local variables must be effectively final because the inner class receives its own private copy of the value, not a live link to the method’s variable.
Prefer static nested classes and, where possible, lambdas to avoid unnecessary references to the outer instance and reduce memory-leak risk.