nested and inner classes

the picture

think of a backpack (the outer object) and a keychain clipped onto it (an inner object). you can carry the keychain around on its own, but it's still clipped to the backpack, so wherever the keychain goes, the backpack comes too. a static nested class is a keychain sold separately: same brand, no clip.

class Outer {
    String name;
    class Inner {
        String hi() { return name; }
    }
}

var i = outer.new Inner();

proof: the hidden fields are real

import java.lang.reflect.Field;
import java.util.function.Supplier;
 
public class Main {
    private String name = "outer";
 
    class Inner {
        String hi() { return "inner of " + name; }
    }
 
    static class Nested {
        String hi() { return "nested"; }
    }
 
    Supplier<String> anon(String greeting) {
        return new Supplier<>() {
            public String get() { return greeting + ", " + name; }
        };
    }
 
    static void fields(Object o) {
        StringBuilder sb = new StringBuilder(o.getClass().getName() + ":");
        for (Field f : o.getClass().getDeclaredFields()) sb.append(" ").append(f.getName());
        System.out.println(sb);
    }
 
    public static void main(String[] args) {
        Main outer = new Main();
        Main.Inner inner = outer.new Inner();
        Main.Nested nested = new Main.Nested();
        Supplier<String> s = outer.anon("hi");
        fields(inner);
        fields(nested);
        fields(s);
        System.out.println(inner.hi() + " / " + s.get());
    }
}

Main$Inner: this$0
Main$Nested:
Main$1: val$greeting this$0
inner of outer / hi, outer

you never wrote a field called this$0 or val$greeting. javac did. the inner class reads name, so it needs the Main. the anonymous class reads greeting, which lives in a stack frame that will be gone by the time get() runs, so javac copies it into the object.

the leak

an inner, local or anonymous object that outlives its outer object keeps the outer object alive. register one as a listener in something long-lived, and the whole outer object (and everything it points to) can never be collected.

·

the fixes, in order of preference:

• make it static (a static nested class, or a top-level one) and pass in only what it needs. no this$0 possible.
• use a lambda that doesn't touch this. a lambda only captures what it uses; if it never mentions an instance member, it doesn't capture the outer object. see lambdas.
• unregister listeners when the owner is done (close(), dispose()), or hold them through a WeakReference.

more ways to leak, and how to find them in a heap dump: memory leaks.

capturing locals: effectively final

local and anonymous classes (and lambdas) copy captured locals into fields when they're created. if java let you change the local afterwards, the copy and the original would silently disagree. so the rule is: you can only capture a local that's effectively final (never assigned after initialization).

void main() {
    int count = 0;
    Runnable r = new Runnable() {
        public void run() {
            IO.println(count);
        }
    };
    count++;
}

error: local variables referenced from an inner class must be final or effectively final. the lambda version says the same thing with "a lambda expression" in it. the usual escape hatch is a one-element array or an AtomicInteger, which keeps the reference final while the contents change. fields are different: an inner class reads them live through this$0, so they can change freely.