What are the kinds of nested classes in Java?

Question

Accepted Answer

A **nested class** is a class defined inside another class. Java has four kinds — **static nested**, **inner (non-static)**, **local**, and **anonymous** — each with different access to the enclosing class and different use cases.

## 1. Static nested class — independent of an instance

```java
public class Outer {
    private static int data = 10;

static class Nested {            // static → no reference to an Outer INSTANCE
        void show() {
            System.out.println(data);  // can access static members of Outer only
        }
    }
}
Outer.Nested n = new Outer.Nested();   // created without an Outer instance
```

A `static` nested class behaves like a top-level class but is namespaced inside the outer one. It does **not** hold a reference to an outer instance — used for grouping helpers (e.g. a `Builder`, `Node` in a data structure).

## 2. Inner (non-static) class — tied to an instance

```java
public class Outer {
    private int value = 5;

class Inner {                     // non-static → has an implicit reference to Outer
        void show() {
            System.out.println(value); // can access Outer's INSTANCE members (even private)
        }
    }
}
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();   // needs an Outer instance to create
```

A non-static **inner** class holds an implicit reference to its enclosing instance, so it can access the outer object's instance fields. (Caution: this reference can cause **memory leaks** if the inner instance outlives the outer.)

## 3. Local class — defined inside a method

```java
void process() {
    class Helper {                    // local to this method
        void run() { ... }
    }
    new Helper().run();
}
```

Rarely used; scoped to the method.

## 4. Anonymous class — one-off implementation, no name

```java
// implement an interface/abstract class inline, for single use
button.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) { handleClick(); }
});

Runnable task = new Runnable() {
    public void run() { System.out.println("running"); }
};
```

An **anonymous** class is a one-shot implementation of an interface or class, defined and instantiated at once — historically common for event handlers and callbacks. Modern Java often replaces these with **lambdas** when the target is a functional interface:

```java
button.addActionListener(e -> handleClick());   // ✅ lambda — much cleaner
Runnable task = () -> System.out.println("running");
```

## Why it matters

Nested classes are a useful tool for **logically grouping** classes that are only used in one context, increasing encapsulation and readability.

Understanding the kinds — especially the **static-vs-inner distinction** (static = independent, inner = holds an enclosing-instance reference) — matters for both design and avoiding bugs: inner classes' implicit outer reference can cause memory leaks, and choosing static when you don't need the outer instance is the cleaner default.

Anonymous classes were the classic way to provide inline implementations (event handlers, comparators), and knowing they're largely superseded by lambdas for functional interfaces reflects modern Java fluency.

These appear throughout the standard library (e.g. `Map.Entry` is a nested interface, builders are static nested classes), making them practical, frequently-encountered knowledge.