Inner Classes & Anonymous Classes

public class Outer {
    private int value = 42;

    class Inner {
        void printValue() {
            System.out.println(value);  // accesses Outer's private field directly, no qualification needed
        }
    }
}

Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();  // requires an outer instance to create
inner.printValue();  // prints 42

Common follow-ups: Why does creating an inner class instance require the unusual outer.new Inner() syntax rather than just new Inner()?;What happens to memory if the outer instance is kept alive solely because an inner class instance derived from it is still referenced?

public class Outer {
    static class Nested {  // no implicit outer reference
        void doWork() { System.out.println("Working independently"); }
    }
}

Outer.Nested nested = new Outer.Nested();  // no outer instance needed at all
nested.doWork();

Common follow-ups: What's the actual memory cost (in bytes) of the implicit outer reference a non-static inner class carries?;How would you convert an existing non-static inner class to static if you later realize it doesn't actually need outer access?

public List<Runnable> createTasks(int count) {
    List<Runnable> tasks = new ArrayList<>();
    class NamedTask implements Runnable {  // local class -- named, reusable within this method
        private final int id;
        NamedTask(int id) { this.id = id; }
        public void run() { System.out.println("Task " + id); }
    }
    for (int i = 0; i < count; i++) {
        tasks.add(new NamedTask(i));  // instantiated multiple times, unlike a typical anonymous class use
    }
    return tasks;
}

Common follow-ups: Why might a local class be preferred over a private nested class if it's genuinely only used within one specific method?;How do local classes interact with generic type parameters from their enclosing method?

// Anonymous class: verbose, but works for any interface (functional or not)
button.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        System.out.println("Clicked!");
    }
});

// Lambda: concise, but ONLY works because ActionListener happens to be a functional interface
button.addActionListener(e -> System.out.println("Clicked!"));

Common follow-ups: What's the specific 'this' semantic difference between an anonymous class and a lambda that could actually change behavior if code depends on it?;Why can't a lambda expression implement an abstract class, even one with only a single abstract method?

// Source-level Java (what you write)
public class Outer {
    private int secret = 42;
    class Inner {
        void reveal() { System.out.println(secret); }  // accesses Outer's private field
    }
}

// Conceptually, the compiler generates something resembling:
// class Outer$Inner {
//     final Outer this$0;  // synthetic field holding the outer instance reference
//     Outer$Inner(Outer outer) { this.this$0 = outer; }
//     void reveal() { System.out.println(Outer.access$000(this$0)); }  // synthetic accessor for the private field
// }

Common follow-ups: Why does the JVM bytecode format not have a native concept of nested classes that source-level Java does?;What performance overhead, if any, do these synthetic accessor methods introduce compared to a direct field access?

public Runnable makeRunnable() {
    int count = 5;
    // count = 10;  // if uncommented AFTER the class below references count, COMPILE ERROR

    class LocalTask implements Runnable {
        public void run() { System.out.println("Count was: " + count); }  // captures count's value
    }
    return new LocalTask();
}

Common follow-ups: Why couldn't Java simply allow full mutable variable capture, the way some other languages (like JavaScript closures) do?;Does this same effectively-final restriction apply to instance fields accessed by a local/anonymous class, or only local variables?

public abstract class Shape {
    abstract double area();
    Shape(String name) { System.out.println("Created: " + name); }
}

Shape customShape = new Shape("CustomCircle") {  // anonymous SUBCLASS, passing a constructor argument
    double radius = 5.0;
    @Override
    double area() { return Math.PI * radius * radius; }
};
System.out.println(customShape.area());

Common follow-ups: Can an anonymous class extending a concrete class add entirely new public methods callable from outside, or are its capabilities limited to what the reference type's static type allows?;Why can't an anonymous class have an explicit, named constructor of its own?

public class Outer {
    private int instanceField = 1;
    private static int staticField = 2;

    public static void staticMethod() {
        class StaticLocal {
            void show() {
                System.out.println(staticField);      // OK: static context, static field accessible
                // System.out.println(instanceField);  // COMPILE ERROR: no outer instance available here!
            }
        }
    }
}

Common follow-ups: Why does a static nested class behave identically to a local class defined in a static context regarding outer-instance access, despite being declared differently?;What compile error message specifically appears if you try to access an instance field from within a class defined in a static context?

public FileVisitor<Path> createVisitor(String targetExtension) {
    class ExtensionCountingVisitor implements FileVisitor<Path> {
        private int matchCount = 0;  // meaningful internal state across multiple method calls

        public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
            if (file.toString().endsWith(targetExtension)) { matchCount++; }
            return FileVisitResult.CONTINUE;
        }
        public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) { return FileVisitResult.CONTINUE; }
        public FileVisitResult postVisitDirectory(Path dir, IOException exc) { return FileVisitResult.CONTINUE; }
        public FileVisitResult visitFileFailed(Path file, IOException exc) { return FileVisitResult.CONTINUE; }
        int getMatchCount() { return matchCount; }  // extra method beyond the interface's own requirements
    }
    return new ExtensionCountingVisitor();
}

Common follow-ups: At what point does a local class's complexity suggest it should instead become a proper named top-level or nested class for better readability/reusability?;How would you achieve similar stateful behavior using only lambdas and an external mutable container instead of a local class?

public class Activity {
    private byte[] largeData = new byte[100_000_000];  // 100MB, associated with this specific Activity instance

    class Listener {
        void onEvent() { /* handle event */ }
    }

    void registerWithLongLivedRegistry(EventRegistry registry) {
        registry.add(new Listener());  // registry now indirectly keeps THIS ENTIRE Activity (and its 100MB) alive!
    }
}

Common follow-ups: How would you fix this specific leak pattern using a static nested class combined with an explicit WeakReference to the outer instance?;Why doesn't this same risk apply to static nested classes, which don't hold any implicit outer reference at all?