Inner Classes & Anonymous Classes

public class LinkedStack<T> implements Iterable<T> {
    private Node<T> head;
    private static class Node<T> { T value; Node<T> next; }

    public Iterator<T> iterator() {
        return new StackIterator();  // private inner class instance
    }

    private class StackIterator implements Iterator<T> {
        private Node<T> current = head;  // directly accesses the OUTER instance's private 'head' field
        public boolean hasNext() { return current != null; }
        public T next() {
            T value = current.value;
            current = current.next;
            return value;
        }
    }
}

Common follow-ups: Why is the Node class itself made a static nested class while the Iterator is a non-static inner class -- what's the reasoning behind that specific choice for each?;How would you support creating multiple independent iterators over the same collection simultaneously, and does this inner-class design naturally support that?

public <T> List<T> processItems(List<T> items) {
    class Wrapper<U> {  // local class with its OWN new generic type parameter U
        U wrapped;
        Wrapper(U value) { wrapped = value; }
    }
    Wrapper<String> w = new Wrapper<>("example");

    // Anonymous class: parameterizes an EXISTING generic interface, doesn't declare a NEW type parameter itself
    Comparator<T> comparator = new Comparator<T>() {  // uses enclosing method's T, no new parameter introduced
        public int compare(T a, T b) { return 0; }
    };
    return items;
}

Common follow-ups: Why specifically can't an anonymous class declare a new generic type parameter of its own, given it can still reference existing ones from its enclosing scope?;How would you work around this anonymous class limitation if you genuinely needed a new type parameter, perhaps by using a local class instead?

// Decision examples illustrating the hierarchy:
Runnable simple = () -> System.out.println("quick task");                    // lambda: simple, functional interface
Comparator<String> cmp = new Comparator<String>() { /* multi-method or needs 'this' */ };  // anonymous: more complex
// local class: named, reusable within one method, possibly with its own constructor
// non-static inner class: Iterator pattern, needs access to outer's private state across its lifetime
// static nested class: a Node in a linked structure, no outer-instance access needed at all

Common follow-ups: What's a concrete example where using a static nested class instead of a non-static inner class would actually change the program's observable behavior, not just its memory characteristics?;How do modern IDEs and static analysis tools help flag an unnecessarily non-static inner class that could be made static?

public class Outer {
    private String name = "outer";

    class Inner {
        private String name = "inner";  // shadows Outer's 'name' field

        void printNames() {
            System.out.println(name);            // "inner" -- refers to Inner's own field
            System.out.println(this.name);       // "inner" -- same, explicit but still Inner's own
            System.out.println(Outer.this.name);  // "outer" -- explicitly qualified, refers to the OUTER instance's field
        }
    }
}

Common follow-ups: Is this same qualified-this syntax needed (or even valid) for a STATIC nested class, given it has no outer instance at all?;How would you access an outer-outer instance from a doubly-nested inner class (an inner class within an inner class)?

public class Outer {
    class Inner { void greet() { System.out.println("Hello from Inner"); } }
}

// From a different, unrelated class:
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();  // requires an existing Outer instance first
inner.greet();

// This would NOT compile: new Outer.Inner();  -- missing the required outer instance

Common follow-ups: Why does this instantiation requirement not apply to static nested classes, which can be created with simple new Outer.Nested() syntax?;Is there a way to change which specific outer instance an already-created inner class instance is associated with, after the fact?