What is the difference between a top-level class and a nested class, and what kinds of nested classes does Java have?

## Top-level vs nested A **top-level class** is declared directly inside a `.java` file, at the outermost level — not inside any other type. A **nested class** is any class declared **inside another class or interface**. The key practical differences: - A top-level class may only use `public` or package-private (no modifier) access, plus `abstract`/`final`/`sealed`. A **nested** class is a *member* (or local element) of its enclosing type, so it may additionally be `private`, `protected`, or `static`. - Nested classes are used to logically group code that is only meaningful in the context of the enclosing class, to increase encapsulation, and to keep helper types close to where they are used. ## The four kinds of nested class Java recognizes four nested forms, split into two groups. **1. Static nested class** — a `static` member class: ```java class Outer { static class Node { int value; } // no link to an Outer instance } ``` It behaves like a top-level class that happens to live inside `Outer`'s namespace. It has **no implicit reference** to an `Outer` instance and can only touch `Outer`'s static members directly. You create one with `new Outer.Node()`. **2. Inner (non-static member) class** — a member class **without** `static`: ```java class Outer { private int x; class Inner { int read() { return x; } } // sees Outer's instance fields } ``` Each `Inner` instance is bound to an enclosing `Outer` instance and can read its members directly (here `x`). You must create it from an outer instance: `outer.new Inner()`. Because it pins an `Outer` instance in memory, careless use can cause memory leaks. **3. Local class** — a named class declared **inside a method** or block: ```java void m() { class Helper { /* ... */ } // visible only inside m() new Helper(); } ``` It is scoped to the enclosing block and can capture **effectively final** local variables (variables not reassigned after initialization). **4. Anonymous class** — a class with **no name**, declared and instantiated in one expression, usually to implement an interface or subclass a type on the spot: ```java Runnable r = new Runnable() { public void run() { System.out.println("hi"); } }; ``` It is a one-off; you cannot reuse or name it. Lambdas have replaced many anonymous-class uses for functional interfaces, but anonymous classes are still needed when you implement multiple methods or extend a class. ## Compiled output Each nested class compiles to its own bytecode file named `Outer$Nested.class` (static and inner member classes), `Outer$1Local.class` for local classes, or `Outer$1.class` for anonymous classes — the `$` separating outer from nested. This is how the JVM, which has no notion of nesting, keeps the namespaces distinct. ## When to use which - **Static nested**: a helper type tightly associated with the outer class but needing no outer instance (e.g. a builder, a node). Prefer this over an inner class when you don't need the enclosing instance — it avoids the hidden reference. - **Inner**: when each instance genuinely belongs to and collaborates with one outer instance (e.g. an iterator over the outer collection). - **Local**: a small helper needed in exactly one method. - **Anonymous**: a tiny one-off implementation, when a lambda won't do.