Java Anonymous Classes Explained — When, Why and How to Use Them

public class AnonymousClassBasics {

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

    public static void main(String[] args) {

        // --- Named class approach (the verbose alternative) ---
        // Normally you'd create a separate FormalGreeter.java file.
        // For one-off use, that's a lot of overhead.

        // --- Anonymous class approach ---
        // We declare AND instantiate a class that implements Greeter,
        // all in one expression. The class has no name we can reference.
        Greeter casualGreeter = new Greeter() {

            // This method body IS the entire class definition
            @Override
            public void greet(String name) {
                System.out.println("Hey " + name + "! What's up?");
            }
        }; // <-- semicolon ends the variable assignment expression

        Greeter formalGreeter = new Greeter() {

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

        casualGreeter.greet("Alice");   // uses first anonymous class
        formalGreeter.greet("Dr. Kim"); // uses second — a completely separate class

        // Prove the compiler gave them different internal names
        System.out.println(casualGreeter.getClass().getName());
        System.out.println(formalGreeter.getClass().getName());
    }
}

public class ScopeCaptureDemo {

    private String companyName = "TheCodeForge"; // instance field — always accessible

    interface MessageSender {
        void send();
    }

    // This method demonstrates what the anonymous class can and can't see
    public MessageSender buildSender(String recipientName, int retryLimit) {

        // 'recipientName' is a parameter — effectively final (never reassigned)
        // 'retryLimit' is also effectively final here

        // This would break: retryLimit = 5; — reassigning makes it NOT effectively final

        return new MessageSender() {

            // Anonymous classes CAN have their own fields
            private int attemptCount = 0;

            @Override
            public void send() {
                attemptCount++; // our own field — no restriction

                // Accessing 'companyName' — the outer instance field
                // Accessing 'recipientName' — captured effectively-final parameter
                // Accessing 'retryLimit' — captured effectively-final parameter
                System.out.println(
                    "[" + companyName + "] Sending to: " + recipientName +
                    " | Attempt: " + attemptCount +
                    " of " + retryLimit
                );

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

    public static void main(String[] args) {
        ScopeCaptureDemo demo = new ScopeCaptureDemo();

        // Build a sender configured for "Bob" with 3 retries
        MessageSender sender = demo.buildSender("Bob", 3);

        sender.send(); // Attempt 1
        sender.send(); // Attempt 2
        sender.send(); // Attempt 3 — triggers the limit message
    }
}

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

public class RealWorldAnonymousClass {

    // Imagine this represents a product in an e-commerce system
    static class Product {
        String name;
        double price;
        int stockCount;

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

        @Override
        public String toString() {
            return name + " ($" + price + ", stock: " + 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)
        ));

        // PATTERN 1: Multi-criteria comparator
        // A lambda can't do this cleanly — we want to sort by stock first
        // (out-of-stock items last), then by price ascending.
        // Anonymous class lets us add a helper method for clarity.
        Comparator<Product> warehouseComparator = new Comparator<Product>() {

            @Override
            public int compare(Product first, Product second) {
                // Push out-of-stock items to the end
                boolean firstOutOfStock  = first.stockCount == 0;
                boolean secondOutOfStock = second.stockCount == 0;

                if (firstOutOfStock != secondOutOfStock) {
                    return firstOutOfStock ? 1 : -1; // out-of-stock goes last
                }

                // Both have stock (or both don't) — sort by price
                return Double.compare(first.price, second.price);
            }

            // A helper that would be impossible in a lambda
            // (lambdas can't have extra methods)
            private boolean isLowStock(Product product) {
                return product.stockCount < 5;
            }
        };

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

        // PATTERN 2: Extending a concrete class inline
        // We want an ArrayList that logs every item added — just for this one list.
        // No lambda can extend ArrayList. An anonymous class can.
        List<String> auditedOrderList = new ArrayList<String>() {
            @Override
            public boolean add(String itemName) {
                System.out.println("[AUDIT] Item added to order: " + itemName);
                return super.add(itemName); // still does the real add
            }
        };

        auditedOrderList.add("Keyboard");
        auditedOrderList.add("Mouse");
        System.out.println("Order contains: " + auditedOrderList);
    }
}