Nested, Inner, Local and Anonymous Classes

New words in this topic, in plain English. Come back here whenever one feels fuzzy.

Nested class

Any class declared inside another class or interface. Its full name includes the outer class: Playlist.Cursor.

Static nested class

A nested class marked static. It has no connection to any object of the outer class and can be created on its own.

Inner class

A nested class without static. Each of its objects is attached to one object of the outer class and can use that object's fields.

Enclosing instance

The outer object an inner object belongs to. Inside the inner class you can name it as Outer.this.

Local class

A class declared inside a method or block. Only code later in that block can use its name.

Anonymous class

A class with no name, declared and created in a single expression such as new Runnable() { public void run() { } }.

Effectively final

A local variable that is never assigned again after it gets its first value, even though it isn't marked final.

Capture

When a local, anonymous class or lambda uses a local variable from the method around it. Java copies the value into the new object.

Functional interface

An interface with exactly one abstract method, like Runnable or Comparator. A lambda can stand in for it.

Synthetic

Generated by the compiler and not written in your source, like the hidden this$0 field of an inner class.

1. 1

   Predict the class files

   Before compiling the 'Local and anonymous classes' example, write down the .class files you expect. Then add a second anonymous Greeter after shout and predict its name. Run javac Main.java and list the folder: you should see Main$2.class appear.

2. 2

   Break the capture rule

   In the same example, add the line greeting = "Hi"; at the very end of main, after the loop. Predict whether it compiles. It doesn't: the assignment makes greeting no longer effectively final, even though it happens after the classes are declared.

3. 3

   Fix the leak

   In the memory-leak example, change ClickHandler so it no longer needs the screen: make it static and give it only the data it needs (ClickHandler(int size)). Create it with new Screen.ClickHandler(10_000_000). Now nothing in the registry reaches the Screen object, so it can be collected once screen = null.

4. 4

   Turn the anonymous class into a lambda

   In the comparator example, replace the anonymous Comparator with Comparator.comparingInt(String::length). Predict the output first: it must be the same first line, because both sort by length and List.sort is stable.

Errors are the best teachers. Make each change, read the error, guess what went wrong, then reveal the answer.

public class Main {
    class Counter { int n; }
    public static void main(String[] args) {
        Counter c = new Counter();
    }
}

public class Main {
    public static void main(String[] args) {
        int count = 0;
        Runnable r = new Runnable() {
            public void run() { count++; }
        };
    }
}

for (int i = 0; i < 3; i++) {
    tasks.add(() -> System.out.println("task " + i));
}

1. 1

   A nested class is any class declared inside another class or interface. There are four kinds. A static nested class (static class Node { } inside a class) has no link to any outer object. An inner class (the same, without static) is attached to one outer object. A local class is declared inside a method body, like a local variable. An anonymous class has no name: it is declared and created in one expression, new Runnable() { ... }. Inner, local and anonymous classes together are called inner classes in the Java Language Specification, because they can all have an enclosing instance.

2. 2

   A static nested class is just a normal top-level class that lives inside another class's name. You write Playlist.Stats from outside and create it with new Playlist.Stats(), no Playlist object needed. It can read the outer class's private static members, and it can read private instance fields *of an object it is handed*, but it has no this of the outer class. Use it for helpers that belong to one class: a linked list's Node, a Builder, a Map.Entry style pair.

3. 3

   An inner class (non-static member class) always carries a hidden reference to its outer object, written Outer.this in source. That is why inner code can read outer fields directly: songs.size() inside Cursor really means Playlist.this.songs.size(). Because of that reference you can only create one *from an outer object*: road.new Cursor(), or plain new Cursor() inside an outer instance method where this is available. From a static method there is no this, and the compiler says non-static variable this cannot be referenced from a static context.

4. 4

   That hidden reference is also the classic memory-leak pitfall. As long as anything reaches the inner object, the outer object cannot be garbage collected, even if nothing else uses it. (Recent javac, JDK 18 onwards, drops the field when the inner code never touches the outer object; older compilers always kept it, and any inner class that does use outer fields always keeps it.) Register an inner-class listener with a long-lived registry and the whole outer object, with every field it holds (a 10 MB image, a database connection, an Android Activity), stays in memory. **Rule of thumb from Effective Java (Item 24): if a member class does not need the outer instance, make it static.**

5. 5

   Local and anonymous classes can read local variables and parameters of the enclosing method, but only if they are final or effectively final: never assigned after their first value (Java 8 added the 'effectively' part; before that you had to write final). The reason is copying: the compiler copies each captured value into a hidden field of the inner object (val$greeting), because the object may outlive the method's stack frame. If the variable could change later, the copy and the original would disagree, so Java forbids the change instead of surprising you.

6. 6

   javac turns every nested class into its **own .class file** named with a $: Playlist$Cursor.class for a member class, Main$1Polite.class for a local class (number plus name), and Main$1.class, Main$2.class for anonymous classes, numbered in source order. The JVM has no real 'inner class' concept; the outer reference is a synthetic constructor parameter and a final field this$0. A lambda (Java 8) is different: no .class file at all, its body becomes a private method lambda$main$0 in the outer class, and an invokedynamic call builds the object at run time. For a functional interface (exactly one abstract method), prefer a lambda; keep an anonymous class when you need state, more than one method, an abstract class, or this to mean the object itself.

• ↔

  Static nested vs inner: static is cheaper (no hidden reference, no leak risk, can be created anywhere), inner is more convenient when the helper truly works on one outer object's state, like an iterator.

• ↔

  Nested vs top-level: nesting keeps a helper private and close to its only user, but large nested classes make the outer file long and hard to navigate. Promote a nested class to top level once other classes need it.

• ↔

  Anonymous class vs lambda: anonymous classes can hold state, implement abstract classes and use this for themselves, but they are verbose, add a class file each, and keep the enclosing instance alive whenever they use it (with javac before JDK 18, even when they don't). Lambdas are concise and capture only what they use, but give less readable stack traces.

• ↔

  Local class vs anonymous class: a local class can be instantiated several times, have a constructor and a name in stack traces; an anonymous class is shorter for a single use.

• Done when you can name the four kinds of nested classes and say which ones have an enclosing instance.

• Done when you can create an inner object from outside (outer.new Inner()) and reach a shadowed outer field with Outer.this.

• Done when you can explain and demonstrate the inner-class memory leak and fix it with a static nested class.

• Done when you can explain effectively final capture and fix the loop-variable compile error.

• Done when you can predict the .class file names javac produces and describe this$0 and val$x.

• Done when you can turn an anonymous class into a lambda and list the cases where you shouldn't.