Nested and Inner Classes

Why Put a Class Inside Another Class?

Java allows you to define a class inside another class. The result is called a nested class, and there are four distinct varieties: static nested classes, non-static inner classes, local classes, and anonymous classes. Each solves a different problem and carries different trade-offs.

The core motivation is encapsulation and co-location. If a class is only ever meaningful in the context of one other class, embedding it there signals that relationship to the reader and keeps the codebase tidy. A LinkedList.Node has no business existing independently of LinkedList, so nesting it makes the dependency explicit. Similarly, a one-off event handler that does a single thing in a single place does not deserve its own file.

Static Nested Classes

A static nested class is declared inside another class with the static modifier. Despite living inside the outer class, it has no connection to any instance of that outer class. You can create a static nested class instance without creating an outer class instance first. To make an instance from outside the outer class, you reference it using the outer class name: OuterClass.NestedClass obj = new OuterClass.NestedClass().

Because there is no implicit outer instance, a static nested class can only access the static members of the outer class directly. It cannot reach instance fields or instance methods of the outer class unless it holds an explicit reference to an outer object. This makes static nested classes the safest choice because they do not create hidden retention of outer instances.

Non-static Inner Classes

A non-static inner class is declared inside another class without the static modifier. Every instance of the inner class holds a hidden reference to the outer class instance that created it. This means the inner class can access all of the outer class's members directly, including private fields and private methods.

To create an inner class instance from outside the enclosing class, you first need an outer class instance, and then you call outerInstance.new InnerClass(). Inside the inner class, if a name collision exists between an outer field and an inner field, you can use OuterClass.this.fieldName to explicitly reach the outer instance's version.

Accessing Outer Class Members from an Inner Class

Non-static inner classes can see all members of the enclosing class: public or private, instance or static. When there is no name conflict, you refer to outer members directly, just as though they were declared in the inner class itself. When there is a conflict (an inner field shadows an outer field with the same name), use the qualified form OuterClass.this.memberName to reach the outer version.

This access follows the same rules as any other access: even private members of the outer class are visible to the inner class because they are in the same compilation unit. The compiler generates the necessary synthetic accessor methods to make this work behind the scenes.

Local Classes

A local class is a class declared inside a method body (or any block, such as an if statement or a loop). Its scope is entirely limited to that block. Once the method returns, the class name is no longer accessible, just like a local variable.

Local classes can access the enclosing method's local variables, but only if those variables are effectively final. A variable is effectively final if it is never reassigned after its initial assignment, even without the final keyword. This restriction exists because the local class instance may outlive the method call (if a reference to it is returned or stored), and capturing a mutable local variable would cause unpredictable behaviour.

Anonymous Classes

An anonymous class is a special shorthand: you declare a class and create exactly one instance of it in a single expression. Because the class has no name, you cannot instantiate it a second time using a constructor call. The syntax looks like a constructor call followed immediately by a class body in curly braces:

new SomeClassOrInterface() { /* override methods here */ }

When you write new SomeInterface() with a body, you are creating an anonymous class that implements the interface. When you write new SomeClass() with a body, you are creating an anonymous class that extends it.

Since Java 8, lambda expressions can replace anonymous classes when the interface has exactly one abstract method (a functional interface). But anonymous classes remain necessary when you are extending a concrete class, implementing a non-functional interface, or needing to hold state in fields.

Anonymous Class with Interface

The most common use of anonymous classes is implementing an interface on the spot. Before lambda expressions arrived in Java 8, this was the standard way to write event handlers, comparators, and callbacks. Even now, it is still the right tool when you need an interface implementation that:

- carries state in its own fields, or

- implements an interface that has more than one abstract method (which rules out lambdas).

When to Use Each Type

Choosing the right kind of nested class is a design decision. Getting it wrong does not usually break the program, but it can make the code harder to read, cause subtle memory leaks, or expose more of the API surface than intended. The following guidelines cover the most common situations.

Quiz - Test Your Knowledge

Ten questions covering static nested classes, non-static inner classes, local classes, anonymous classes, the effectively-final rule, memory implications, and the relationship between anonymous classes and lambda expressions. Read each option carefully before selecting your answer.