Java Anonymous Classes — this$0 Synthetic Field Traps

package io.thecodeforge.lang;

/**
 * Demonstrates the basics of anonymous class syntax and shows exactly
 * what the compiler generates behind the scenes.
 *
 * After compiling this file, check your build output directory:
 * You'll find AnonymousClassBasics$1.class and AnonymousClassBasics$2.class
 * alongside AnonymousClassBasics.class. Three files from one source file.
 */
public class AnonymousClassBasics {

    // A simple interface representing anything that can greet someone
    interface Greeter {
        void greet(String name);
    }

    public static void main(String[] args) {

        // --- What the verbose alternative looks like ---
        // You'd normally create CasualGreeter.java and FormalGreeter.java as
        // separate named classes. For one-time use, that's real overhead:
        // two extra files, two types to name and track, no real benefit.

        // --- Anonymous class approach ---
        // Declare AND instantiate in one expression.
        // The Greeter variable holds an instance of a class that has no name
        // we can reference — only the compiler's internal name Outer$1.
        Greeter casualGreeter = new Greeter() {

            @Override
            public void greet(String name) {
                // 'this' inside here refers to the anonymous class instance,
                // not to the main method or AnonymousClassBasics class.
                System.out.println("Hey " + name + "! What's up?");
            }

        }; // <-- This semicolon ends the assignment statement, not the class.
           //     Missing it is a common compile error that points to the wrong line.

        // Second anonymous class — same interface, completely different class.
        // Compiler generates AnonymousClassBasics$2 for this one.
        Greeter formalGreeter = new Greeter() {

            @Override
            public void greet(String name) {
                System.out.println("Good day, " + name + ". Welcome.");
            }

        };

        casualGreeter.greet("Alice");   // Dispatches through AnonymousClassBasics$1
        formalGreeter.greet("Dr. Kim"); // Dispatches through AnonymousClassBasics$2

        // The compiler's internal names are runtime-visible through reflection.
        // This is what appears in stack traces and heap dumps.
        System.out.println("Casual greeter class: " + casualGreeter.getClass().getName());
        // Output: io.thecodeforge.lang.AnonymousClassBasics$1

        System.out.println("Formal greeter class: " + formalGreeter.getClass().getName());
        // Output: io.thecodeforge.lang.AnonymousClassBasics$2

        // These are two distinct classes. They share no type relationship
        // with each other — only with the Greeter interface.
        System.out.println("Same class? " +
            (casualGreeter.getClass() == formalGreeter.getClass())); // false
    }
}

package io.thecodeforge.lang;

/**
 * Demonstrates scope capture rules for anonymous classes:
 * - What can be captured (and the constraints)
 * - The difference between captured locals (copies) and outer instance (live reference)
 * - The common pattern to work around effectively-final limitations
 */
public class ScopeCaptureDemo {

    // Instance field of the outer class — accessible freely, no final restriction.
    // But this access is mediated through the implicit this$0 reference.
    private String companyName = "TheCodeForge";

    interface MessageSender {
        void send();
    }

    public MessageSender buildSender(String recipientName, int retryLimit) {
        // 'recipientName' and 'retryLimit' are method parameters.
        // As long as we never reassign them, they're effectively final.
        // The compiler will accept them being captured.

        // If we added this line: retryLimit = 5;
        // ...the anonymous class below would fail to compile because retryLimit
        // would no longer be effectively final. The compiler checks all assignments
        // to the variable, not just ones after the anonymous class.

        // Pattern: when you need a mutable-looking value, capture it at the right moment.
        // final int adjustedLimit = retryLimit + 1; // effectively final copy

        return new MessageSender() {

            // Anonymous classes CAN declare their own fields.
            // These are not subject to effectively-final rules.
            private int attemptCount = 0;

            @Override
            public void send() {
                attemptCount++; // Own field — mutate freely.

                // Accessing companyName: goes through this$0 to reach the outer instance.
                // Accessing recipientName: reads from the synthetic copy stored in this class.
                // Accessing retryLimit: same — synthetic copy, not a live variable reference.
                System.out.printf(
                    "[%s] Sending to: %s | Attempt %d of %d%n",
                    companyName,    // outer instance field via this$0
                    recipientName,  // captured copy
                    attemptCount,   // own field
                    retryLimit      // captured copy
                );

                if (attemptCount >= retryLimit) {
                    System.out.println("Max retries reached. Aborting.");
                }
            }
        };
    }

    // Demonstrates the memory danger: if buildSender() were static,
    // the returned anonymous class would have no outer instance.
    // Since it's non-static, every returned MessageSender holds
    // a ScopeCaptureDemo instance alive.
    public static void main(String[] args) {
        ScopeCaptureDemo demo = new ScopeCaptureDemo();
        MessageSender sender = demo.buildSender("Alice", 3);

        sender.send(); // Attempt 1 of 3
        sender.send(); // Attempt 2 of 3
        sender.send(); // Attempt 3 of 3 — triggers abort message

        // If 'sender' were stored in a static field here,
        // 'demo' could never be garbage collected.
        // That's the implicit-reference trap.
    }
}

package io.thecodeforge.lang;

import java.util.Arrays;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

/**
 * Two patterns where anonymous classes remain the right tool in 2026,
 * even with lambdas available:
 *
 * 1. Comparator with private helper methods — lambdas can't have helper methods
 * 2. Inline class extension with overridden behavior — lambdas can't extend classes
 */
public class RealWorldAnonymousClass {

    static class Product {
        final String name;
        final double price;
        final int stockCount;

        Product(String name, double price, int stockCount) {
            this.name = name;
            this.price = price;
            this.stockCount = stockCount;
        }

        @Override
        public String toString() {
            return String.format("%s ($%.2f, stock: %d)", name, price, stockCount);
        }
    }

    public static void main(String[] args) {

        List<Product> inventory = new ArrayList<>(Arrays.asList(
            new Product("Keyboard", 79.99,  15),
            new Product("Monitor",  349.00,  3),
            new Product("Mouse",    29.99,  42),
            new Product("Webcam",   89.99,   0)  // out of stock
        ));

        // --- PATTERN 1: Comparator with a private helper method ---
        //
        // A lambda could handle the sort logic, but we'd lose the ability
        // to extract the isOutOfStock check into a named helper.
        // Private helpers inside an anonymous class document intent at the
        // call site without requiring a separate utility method on the outer class.
        //
        // Sort rule: in-stock items first (sorted by price ascending),
        //            out-of-stock items last (sorted by name alphabetically).
        Comparator<Product> warehouseComparator = new Comparator<Product>() {

            @Override
            public int compare(Product first, Product second) {
                boolean firstOut  = isOutOfStock(first);
                boolean secondOut = isOutOfStock(second);

                // Different stock status: in-stock items come before out-of-stock
                if (firstOut != secondOut) {
                    return firstOut ? 1 : -1;
                }

                // Both have stock: sort by price ascending
                if (!firstOut) {
                    return Double.compare(first.price, second.price);
                }

                // Both out of stock: sort alphabetically by name
                return first.name.compareTo(second.name);
            }

            // This private helper cannot exist in a lambda.
            // It clarifies intent without polluting the outer class's API.
            private boolean isOutOfStock(Product p) {
                return p.stockCount == 0;
            }
        };

        inventory.sort(warehouseComparator);
        System.out.println("=== Sorted Inventory ===");
        inventory.forEach(System.out::println);
        System.out.println();

        // --- PATTERN 2: Extending a concrete class inline ---
        //
        // We want an ArrayList that logs every item added — but only for this
        // specific order list, not globally. No lambda can extend ArrayList.
        // An anonymous class can extend any non-final class.
        //
        // Note: this anonymous class is created in a static context (main method),
        // so there is no outer instance reference — no memory leak risk here.
        List<String> auditedOrder = new ArrayList<String>() {

            @Override
            public boolean add(String itemName) {
                System.out.println("[AUDIT] Adding to order: " + itemName);
                return super.add(itemName); // delegates to real ArrayList.add()
            }

            @Override
            public boolean remove(Object itemName) {
                System.out.println("[AUDIT] Removing from order: " + itemName);
                return super.remove(itemName);
            }
        };

        auditedOrder.add("Keyboard");
        auditedOrder.add("Mouse");
        auditedOrder.remove("Mouse"); // also audited
        System.out.println("Final order: " + auditedOrder);
    }
}

// io.thecodeforge — java tutorial

import java.util.concurrent.*;

public class AnonymousMemoryLeakDemo {
    private final int[] expensiveData = new int[10_000_000]; // 80 MB

    public Runnable createLeakyTask() {
        // This anonymous class implicitly holds a reference to the entire
        // AnonymousMemoryLeakDemo instance, even if it never uses 'expensiveData'.
        return new Runnable() {
            @Override
            public void run() {
                System.out.println("Running task");
                // 'this' here refers to the Runnable, but 'LeakyDemo.this' is
                // implicitly reachable from the compiler-generated synthetic field.
            }
        };
    }

    public Runnable createSafeTask() {
        // Static nested class — no implicit 'this'.
        return new SafeRunnable();
    }

    private static class SafeRunnable implements Runnable {
        @Override
        public void run() {
            System.out.println("Running safe task");
        }
    }

    public static void main(String[] args) {
        ExecutorService pool = Executors.newSingleThreadExecutor();
        AnonymousMemoryLeakDemo demo = new AnonymousMemoryLeakDemo();
        pool.execute(demo.createLeakyTask()); // demo instance can't be GC'd until task completes
        pool.execute(demo.createSafeTask());  // only SafeRunnable is referenced
        pool.shutdown();
    }
}

// io.thecodeforge — java tutorial

import java.util.function.Consumer;

public class StackTraceClarityDemo {

    public void processWithAnonymous() {
        // This will show up as StackTraceClarityDemo$1.<init> in the trace
        Consumer<String> processor = new Consumer<String>() {
            @Override
            public void accept(String input) {
                if (input == null) {
                    throw new IllegalArgumentException("Input cannot be null");
                }
                System.out.println("Processing: " + input);
            }
        };
        processor.accept(null);
    }

    public void processWithNamed() {
        Consumer<String> processor = new NullCheckConsumer();
        processor.accept(null);
    }

    private static class NullCheckConsumer implements Consumer<String> {
        @Override
        public void accept(String input) {
            if (input == null) {
                throw new IllegalArgumentException("Input cannot be null");
            }
            System.out.println("Processing: " + input);
        }
    }

    public static void main(String[] args) {
        StackTraceClarityDemo demo = new StackTraceClarityDemo();
        try {
            demo.processWithAnonymous();
        } catch (Exception e) {
            System.out.println("Anonymous stack trace:");
            e.printStackTrace(System.out);
        }

        try {
            demo.processWithNamed();
        } catch (Exception e) {
            System.out.println("\nNamed stack trace:");
            e.printStackTrace(System.out);
        }
    }
}

// io.thecodeforge — java tutorial

public class AnonymousBasics {
    interface Action {
        void execute();
        String describe();
    }

    public static void main(String[] args) {
        Action action = new Action() {
            @Override
            public void execute() {
                System.out.println("Running");
            }
            @Override
            public String describe() {
                return "Anonymous Action";
            }
        };
        System.out.println(action.describe());
    }
}

// io.thecodeforge — java tutorial

import java.util.function.Consumer;

public class Comparison {
    public static void main(String[] args) {
        // Lambda – single method
        Consumer<String> c = s -> System.out.println(s);

        // Anonymous – multiple methods
        Runnable r = new Runnable() {
            public void run() { log(); }
            void log() { System.out.println("run"); }
        };

        // Method reference
        Consumer<String> m = System.out::println;
    }
}