Inner Classes & Anonymous Classes

public class Main {
    // A STATIC nested class has NO link to a Main instance.
    // It is just a top-level class that happens to live inside Main,
    // so it can be a self-contained helper grouped with its owner.
    static class Point {
        final int x;
        final int y;
        Point(int x, int y) { this.x = x; this.y = y; }

        double distanceTo(Point other) {
            int dx = x - other.x;
            int dy = y - other.y;
            return Math.sqrt(dx * dx + dy * dy);  // straight-line distance
        }

        @Override public String toString() { return "(" + x + ", " + y + ")"; }
    }

    public static void main(String[] args) {
        // Create it with the OUTER name as a prefix — no Main object needed.
        Point a = new Main.Point(0, 0);
        Point b = new Point(3, 4);              // inside Main, the prefix is optional

        System.out.println("a = " + a);          // (0, 0)
        System.out.println("b = " + b);          // (3, 4)
        System.out.println("distance = " + a.distanceTo(b));  // 5.0
    }
}

a = (0, 0)
b = (3, 4)
distance = 5.0

public class Main {
    static class Counter {
        private int count = 0;               // a field of the OUTER object

        void increment() { count++; }

        // A NON-STATIC inner class. Each Ticker is tied to ONE Counter
        // instance and can read/write that Counter's fields directly.
        class Ticker {
            // No 'count' here — it reaches OUT to the enclosing Counter.
            String report() {
                // 'count' means Counter.this.count — the outer instance.
                return "count is now " + count;
            }
            void bump() { count++; }          // mutates the outer object
        }

        // Build an inner instance from a Counter: outer.new Inner()
        Ticker newTicker() { return new Ticker(); }
    }

    public static void main(String[] args) {
        Counter c = new Counter();
        c.increment();                        // count = 1

        // An inner instance needs an enclosing instance to exist.
        Counter.Ticker t = c.newTicker();     // same as: c.new Ticker()
        System.out.println(t.report());        // count is now 1

        t.bump();                              // inner class changes the OUTER field
        System.out.println(t.report());        // count is now 2
    }
}

count is now 1
count is now 2

import java.util.Arrays;
import java.util.Comparator;

public class Main {
    record Word(String text) {}

    public static void main(String[] args) {
        String prefix = "len=";              // effectively final — usable below

        // LOCAL CLASS: declared inside a method, only visible in this method.
        // It can capture 'prefix' because that variable never changes.
        class Labeller {
            String label(Word w) { return prefix + w.text().length(); }
        }
        Labeller labeller = new Labeller();
        System.out.println(labeller.label(new Word("hello")));  // len=5

        Word[] words = { new Word("pear"), new Word("fig"), new Word("cherry") };

        // ANONYMOUS CLASS: an unnamed one-off implementation of Comparator.
        Comparator<Word> byLengthAnon = new Comparator<Word>() {
            @Override public int compare(Word a, Word b) {
                return Integer.compare(a.text().length(), b.text().length());
            }
        };

        // LAMBDA: the same single-method interface, far less boilerplate.
        Comparator<Word> byLengthLambda =
            (a, b) -> Integer.compare(a.text().length(), b.text().length());

        Arrays.sort(words, byLengthAnon);
        System.out.print("anon:   ");
        for (Word w : words) System.out.print(w.text() + " ");
        System.out.println();

        Arrays.sort(words, byLengthLambda);
        System.out.print("lambda: ");
        for (Word w : words) System.out.print(w.text() + " ");
        System.out.println();
    }
}

len=5
anon:   fig pear cherry
lambda: fig pear cherry

public class Main {
    // A registry that keeps callbacks alive for the program's lifetime.
    static class EventBus {
        // For the demo we just store one handler.
        Runnable handler;
        void register(Runnable r) { handler = r; }
        void fire() { if (handler != null) handler.run(); }
    }

    // ❌ LEAKY: a non-static inner class. Every Screen.Handler secretly holds
    //    a reference to its Screen, so registering one keeps the WHOLE Screen
    //    (and everything it owns) alive as long as the EventBus lives.
    static class Screen {
        String name;
        Screen(String name) { this.name = name; }
        class Handler implements Runnable {
            public void run() { System.out.println("handling for " + name); }
        }
        Runnable leakyHandler() { return new Handler(); }
    }

    // ✅ SAFE: a static nested class holds NO outer reference. Pass in only the
    //    small piece of data it needs, so the big object can be collected.
    static class SafeHandler implements Runnable {
        private final String label;          // just a String, not the whole Screen
        SafeHandler(String label) { this.label = label; }
        public void run() { System.out.println("handling for " + label); }
    }

    public static void main(String[] args) {
        EventBus bus = new EventBus();

        Screen screen = new Screen("Home");
        bus.register(screen.leakyHandler());  // bus now pins the entire Screen
        bus.fire();                            // handling for Home

        bus.register(new SafeHandler("Home")); // bus pins only a String
        bus.fire();                            // handling for Home
    }
}

handling for Home
handling for Home