{"title":"Anonymous Classes","description":"","content":"Some classes exist for exactly one purpose, in exactly one place, and never get used again. Writing a full named class for a one-off use is a lot of ceremony for very little payoff. Anonymous classes are Java's answer to that: they let you declare a class, instantiate it, and use the instance in one expression. This lesson walks through the syntax, what the compiler actually produces, the rules around captured variables, and the limits that anonymous classes hit when you try to push them too far.\n\n---\n\n# The Problem Anonymous Classes Solve\n\nConsider a list of products you want to sort by price for a single screen in your app. The standard way to sort by a custom rule is to pass a `Comparator` to `Collections.sort`. A `Comparator` is an interface with a `compare` method that returns a negative, zero, or positive number depending on which item should come first.\n\nWithout anonymous classes, you have to declare a separate class for the comparator.\n\n\n```java\nimport java.util.ArrayList;\nimport java.util.Collections;\nimport java.util.List;\n\npublic class SortByPriceNamed {\n static class Product {\n String name;\n double price;\n Product(String name, double price) {\n this.name = name;\n this.price = price;\n }\n }\n\n static class ProductPriceComparator implements java.util.Comparator {\n @Override\n public int compare(Product a, Product b) {\n return Double.compare(a.price, b.price);\n }\n }\n\n public static void main(String[] args) {\n List cart = new ArrayList<>();\n cart.add(new Product(\"Headphones\", 49.99));\n cart.add(new Product(\"USB Cable\", 9.99));\n cart.add(new Product(\"Wireless Mouse\", 29.99));\n\n Collections.sort(cart, new ProductPriceComparator());\n\n for (Product p : cart) {\n System.out.println(p.name + \" $\" + p.price);\n }\n }\n}\n```\n\n\nThis works, but `ProductPriceComparator` is a whole top-level idea (a class with a name and a file location) for one line of logic that's only used once. If you needed a different sort order on the next screen (by name, by rating, by stock), you'd be writing a new named class every time. That's a lot of files for what is, at heart, three lines of comparison code.\n\nAn anonymous class lets you skip the naming step. You declare the class right where you need an instance of it.\n\n\n```java\nimport java.util.ArrayList;\nimport java.util.Collections;\nimport java.util.Comparator;\nimport java.util.List;\n\npublic class SortByPriceAnonymous {\n static class Product {\n String name;\n double price;\n Product(String name, double price) {\n this.name = name;\n this.price = price;\n }\n }\n\n public static void main(String[] args) {\n List cart = new ArrayList<>();\n cart.add(new Product(\"Headphones\", 49.99));\n cart.add(new Product(\"USB Cable\", 9.99));\n cart.add(new Product(\"Wireless Mouse\", 29.99));\n\n Collections.sort(cart, new Comparator() {\n @Override\n public int compare(Product a, Product b) {\n return Double.compare(a.price, b.price);\n }\n });\n\n for (Product p : cart) {\n System.out.println(p.name + \" $\" + p.price);\n }\n }\n}\n```\n\n\nSame output, no separate `ProductPriceComparator` class. The block starting with `new Comparator() { ... }` is the anonymous class: it defines a class that implements `Comparator`, builds one instance of that class, and hands that instance to `Collections.sort`. The class itself has no name you can refer to.\n\n---\n\n# The Syntax\n\nThere are two shapes for an anonymous class, depending on whether you're implementing an interface or extending a class.\n\n\n```shell\n// Form 1: implement an interface\nnew SomeInterface() {\n // method overrides\n}\n\n// Form 2: extend a class\nnew SomeClass(constructorArgs) {\n // method overrides or new methods\n}\n```\n\n\nIn both cases, the `new` keyword does three things at once: it declares the anonymous class, instantiates it, and gives you back the reference. The braces after the parentheses hold the class body, exactly like a named class body, with field declarations, methods, and initializer blocks.\n\nA small breakdown of what a single anonymous-class expression contains.\n\n\n```mermaid\nflowchart LR\n Expr[\"new Comparator() { ... }\"]:::cyan --> Class[Synthetic class
e.g. Outer$1]:::orange\n Expr --> Inst[New instance
of that class]:::green\n Expr --> Ref[Reference handed
back to caller]:::teal\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n```\n\n\nThe diagram says it visually: one expression, three results. When you write `new Comparator() { ... }`, the compiler invents a class for you, builds one instance of it, and gives you back the reference. You can ignore the class part and use the reference directly, which is what makes the syntax compact.\n\nA smaller example that doesn't depend on collections. If you have a `Runnable` you want to use once:\n\n\n```java\npublic class GreetingRunner {\n public static void main(String[] args) {\n Runnable greeting = new Runnable() {\n @Override\n public void run() {\n System.out.println(\"Welcome to AlgoMart!\");\n }\n };\n greeting.run();\n }\n}\n```\n\n\n`Runnable` is a built-in interface with one method: `run`. The anonymous class implements it, prints a line, and gets stored in `greeting`. Calling `greeting.run()` invokes the body of the anonymous class.\n\n---\n\n# What the Compiler Actually Generates\n\nAn anonymous class isn't magic. The compiler turns it into a real class with a synthetic name. If your file is `Outer.java`, the first anonymous class declared inside `Outer` becomes a class file named `Outer$1.class`, the second becomes `Outer$2.class`, and so on. The number reflects declaration order in the source file, not call order at runtime.\n\nTake the sort example. After compilation, you'd see something like:\n\n\n```shell\nSortByPriceAnonymous.class\nSortByPriceAnonymous$1.class // the anonymous Comparator\nSortByPriceAnonymous$Product.class\n```\n\n\nThe `$1` file holds the class the compiler generated from `new Comparator() { ... }`. It implements `Comparator`, has the `compare` method you wrote, and ends up being a perfectly normal class as far as the JVM is concerned. The only odd thing is the name, which you can't write in source code.\n\n\n```mermaid\nflowchart LR\n Src[\"Source:
new Comparator { compare }\"]:::cyan --> Compile[Java compiler]:::orange\n Compile --> Cls[Outer$1.class
implements Comparator]:::green\n Compile --> Site[Bytecode at call site:
new Outer$1 then invoke]:::teal\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n```\n\n\nWhy does this matter? Two practical reasons. First, when you see `MyApp$1` in a stack trace, that's an anonymous class showing up by its compiler-generated name. Second, knowing the compiler builds a real class explains why anonymous classes can have fields and constructors-via-initializers, and why they participate in the type system like any other class.\n\n---\n\n# Implementing an Interface\n\nImplementing an interface is the most common use of anonymous classes. The shape is `new SomeInterface() { /* override methods */ }`. Because interfaces don't have constructors, the parentheses after the type name are always empty.\n\nHere's a cart example with a custom filter. To find expensive items (price above some threshold) for a \"review your big purchases\" screen: You could write a `Predicate` interface and pass an anonymous implementation.\n\n\n```java\nimport java.util.ArrayList;\nimport java.util.List;\nimport java.util.function.Predicate;\n\npublic class ExpensiveItems {\n static class Product {\n String name;\n double price;\n Product(String name, double price) {\n this.name = name;\n this.price = price;\n }\n }\n\n public static void main(String[] args) {\n List cart = new ArrayList<>();\n cart.add(new Product(\"USB Cable\", 9.99));\n cart.add(new Product(\"Headphones\", 49.99));\n cart.add(new Product(\"Wireless Mouse\", 29.99));\n cart.add(new Product(\"4K Monitor\", 299.00));\n\n Predicate expensive = new Predicate() {\n @Override\n public boolean test(Product product) {\n return product.price > 50.0;\n }\n };\n\n for (Product p : cart) {\n if (expensive.test(p)) {\n System.out.println(\"Big purchase: \" + p.name + \" $\" + p.price);\n }\n }\n }\n}\n```\n\n\n`Predicate` is a built-in interface with a single method `test` that takes a value and returns a `boolean`. The anonymous class implements `test` and gets stored in the local variable `expensive`. From the loop's point of view, `expensive` is just a `Predicate`. It doesn't care whether the implementation came from an anonymous class, a named class, or somewhere else.\n\nYou can implement interfaces with more than one method too, but you have to override every method that doesn't have a default implementation. For interfaces with a single abstract method (functional interfaces), the anonymous class form is the historical way to provide an implementation. Lambdas are the next-generation, shorter alternative for that single case, but anonymous classes are still needed when you have to override more than one method or want to add fields.\n\n---\n\n# Subclassing a Class\n\nThe second form extends an existing class instead of implementing an interface. The parentheses can take arguments, which get forwarded to a constructor of the parent class.\n\nConsider a `Logger` class that prints messages with a prefix, and on one screen you want a one-off version that adds a timestamp to every line. You can subclass `Logger` inline.\n\n\n```java\npublic class StoreLogger {\n static class Logger {\n String prefix;\n\n Logger(String prefix) {\n this.prefix = prefix;\n }\n\n void log(String message) {\n System.out.println(prefix + \": \" + message);\n }\n }\n\n public static void main(String[] args) {\n Logger normal = new Logger(\"CART\");\n normal.log(\"Item added\");\n\n Logger timestamped = new Logger(\"CART\") {\n @Override\n void log(String message) {\n long now = System.currentTimeMillis();\n System.out.println(\"[\" + now + \"] \" + prefix + \": \" + message);\n }\n };\n timestamped.log(\"Item added\");\n }\n}\n```\n\n\n**Output (timestamp value will differ):**\n\n\n```shell\nCART: Item added\n[1715600000000] CART: Item added\n```\n\n\nThe expression `new Logger(\"CART\") { ... }` does three things: it invokes the `Logger(String)` constructor with the argument `\"CART\"`, declares a new class that extends `Logger`, and creates one instance of that subclass. Inside the override of `log`, the field `prefix` is the one inherited from `Logger`, which got set by the parent's constructor.\n\nThis is the form you use when you need to override a method on a concrete or abstract class for just one place. The parent class can be abstract, in which case you must override every abstract method, or it can be concrete, in which case you only override what you want to change.\n\n---\n\n# Capturing Local Variables\n\nAn anonymous class declared inside a method can use the enclosing method's local variables, but only if those variables are `final` or effectively final. \"Effectively final\" means the compiler can see that you never assigned to the variable after its initial assignment. You don't have to write the `final` keyword; you just have to not reassign the variable.\n\nThis rule exists because, internally, the anonymous class captures a copy of the variable's value at the moment the instance is created. If the local variable could change after capture, the copy inside the anonymous class would silently drift away from the original. Java avoids that confusion by forbidding the case entirely.\n\nA working example: a one-off button-style listener that prints which customer placed an order.\n\n\n```java\npublic class OrderListener {\n interface OrderEventListener {\n void onOrderPlaced(int orderId);\n }\n\n public static void main(String[] args) {\n String customerName = \"Alice\";\n\n OrderEventListener listener = new OrderEventListener() {\n @Override\n public void onOrderPlaced(int orderId) {\n System.out.println(customerName + \" placed order \" + orderId);\n }\n };\n\n listener.onOrderPlaced(1042);\n }\n}\n```\n\n\n`customerName` is a local variable of `main`. The anonymous class uses it inside `onOrderPlaced`. Because `customerName` is never reassigned, it's effectively final, and the capture works.\n\nNow look at what breaks the rule.\n\n**What's wrong with this code?**\n\n\n```java\npublic class BrokenCapture {\n interface OrderEventListener {\n void onOrderPlaced(int orderId);\n }\n\n public static void main(String[] args) {\n String customerName = \"Alice\";\n customerName = \"Bob\"; // reassignment breaks \"effectively final\"\n\n OrderEventListener listener = new OrderEventListener() {\n @Override\n public void onOrderPlaced(int orderId) {\n System.out.println(customerName + \" placed order \" + orderId);\n // Compile error: local variable customerName defined in an\n // enclosing scope must be final or effectively final\n }\n };\n\n listener.onOrderPlaced(1042);\n }\n}\n```\n\n\n**Fix:** stop reassigning the variable, or move the value into a new variable that you don't reassign.\n\n\n```java\npublic class FixedCapture {\n interface OrderEventListener {\n void onOrderPlaced(int orderId);\n }\n\n public static void main(String[] args) {\n String chosenName = \"Bob\"; // never reassigned\n\n OrderEventListener listener = new OrderEventListener() {\n @Override\n public void onOrderPlaced(int orderId) {\n System.out.println(chosenName + \" placed order \" + orderId);\n }\n };\n\n listener.onOrderPlaced(1042);\n }\n}\n```\n\n\nThe rule applies to every local variable the anonymous class touches, including parameters of the enclosing method (parameters are local variables that just happen to have a starting value).\n\nA common follow-up question: what if you really do need a value the anonymous class can update? The standard pattern is to wrap the value in a one-element array or in an object with a mutable field. That's a workaround, not a fix to the language rule, but it covers the cases where you actually need shared mutable state.\n\n---\n\n# Access to Enclosing-Class Members\n\nWhen an anonymous class is declared inside an instance method, it has access to the enclosing instance's fields and methods, similar to inner classes. The anonymous class holds a hidden reference to the outer instance, and it can read or call any member of that instance, including `private` ones. This section just shows the form that comes up most often with anonymous classes.\n\nHere's an example. A `CartManager` instance method registers a small \"after add\" hook that logs the cart owner's name. The hook is an anonymous class, and inside `onItemAdded` it reads the enclosing `CartManager`'s `customerName` field.\n\n\n```java\npublic class CartManager {\n interface CartHook {\n void onItemAdded(String item);\n }\n\n private String customerName;\n\n public CartManager(String customerName) {\n this.customerName = customerName;\n }\n\n public CartHook buildAddLogger() {\n return new CartHook() {\n @Override\n public void onItemAdded(String item) {\n System.out.println(customerName + \" added \" + item);\n }\n };\n }\n\n public static void main(String[] args) {\n CartManager manager = new CartManager(\"Alice\");\n CartHook hook = manager.buildAddLogger();\n hook.onItemAdded(\"Wireless Mouse\");\n hook.onItemAdded(\"USB Cable\");\n }\n}\n```\n\n\n`buildAddLogger` is an instance method on `CartManager`. The anonymous class inside it can read `customerName`, the enclosing instance's field, with no extra ceremony. That field isn't a local variable, so the \"effectively final\" rule doesn't apply: fields belong to the object and can change freely.\n\nOne point about `this` inside the anonymous class. Writing `this` from inside the anonymous class refers to the anonymous-class instance, not the enclosing `CartManager`. To refer to the enclosing instance, write `CartManager.this`.\n\n**What's wrong with this code?**\n\n\n```java\npublic class WrongThis {\n String label = \"outer\";\n\n void run() {\n Runnable task = new Runnable() {\n String label = \"inner\";\n\n @Override\n public void run() {\n // Intent: print the outer label. Actually prints the inner one.\n System.out.println(this.label);\n }\n };\n task.run();\n }\n\n public static void main(String[] args) {\n new WrongThis().run();\n }\n}\n```\n\n\n**Output (which is the bug):**\n\n\n```shell\ninner\n```\n\n\n**Fix:** use the qualified form `WrongThis.this.label` to reach the enclosing instance's field.\n\n\n```java\npublic class FixedThis {\n String label = \"outer\";\n\n void run() {\n Runnable task = new Runnable() {\n String label = \"inner\";\n\n @Override\n public void run() {\n System.out.println(FixedThis.this.label);\n }\n };\n task.run();\n }\n\n public static void main(String[] args) {\n new FixedThis().run();\n }\n}\n```\n\n\n`this` inside an anonymous class always means the anonymous instance. The enclosing object lives behind `EnclosingClassName.this`. The trap is real: when both classes have a field with the same name, the inner one wins under `this`, and the bug only shows up at runtime as a wrong value, not a compile error.\n\n---\n\n# Limits of Anonymous Classes\n\nAnonymous classes can do a lot, but the language draws several lines around them.\n\n### No Named Constructor\n\nAn anonymous class can't declare a constructor with its own parameter list. There's no name to put before the parentheses. The expression `new ParentClass(args) { ... }` does pass `args` to the parent's constructor, but the anonymous subclass itself can't add a different constructor with its own arguments.\n\nIf you need to set up fields specific to the anonymous class, the workaround is an **instance initializer block**: a `{ ... }` block inside the class body (not a method) that runs after the parent constructor.\n\n\n```java\nimport java.util.HashMap;\nimport java.util.Map;\n\npublic class CartInitializer {\n public static void main(String[] args) {\n Map sampleCart = new HashMap() {\n {\n put(\"Wireless Mouse\", 29.99);\n put(\"USB Cable\", 9.99);\n }\n };\n\n for (Map.Entry entry : sampleCart.entrySet()) {\n System.out.println(entry.getKey() + \" -> $\" + entry.getValue());\n }\n }\n}\n```\n\n\n**Output (order may vary):**\n\n\n```shell\nUSB Cable -> $9.99\nWireless Mouse -> $29.99\n```\n\n\nThe braces inside the anonymous class body, before any method, form an instance initializer. They run as part of construction. This pattern was a popular shortcut for initializing collections inline before Java 9's `Map.of` and `List.of` factory methods made it unnecessary. The pattern still works, but it does carry a small cost.\n\nEvery \"double-brace\" initializer like this produces an anonymous subclass of `HashMap`. The subclass holds a hidden reference to the enclosing instance, which can keep objects alive longer than expected and increase memory pressure if you create thousands of these. For modern Java, prefer `Map.of(...)` or build the map in a static helper method.\n\n### No Static Members (Except Constants)\n\nAn anonymous class can't declare static methods, and it can't declare static fields unless they're compile-time constants (`static final` with a literal value or a constant expression). The rule comes from the fact that the anonymous class doesn't have a usable name, so there's nothing to put before `.staticMember` to refer to such a member from the outside.\n\n\n```java\npublic class NoStaticHere {\n interface Greeting {\n void greet();\n }\n\n public static void main(String[] args) {\n Greeting hello = new Greeting() {\n static final String DEFAULT = \"Hello\"; // OK: compile-time constant\n\n // static int counter = 0; // Compile error\n // static void helper() {} // Compile error\n\n @Override\n public void greet() {\n System.out.println(DEFAULT + \", customer!\");\n }\n };\n hello.greet();\n }\n}\n```\n\n\nThe `static final String DEFAULT` is fine because it's a constant. A non-final static field or a regular static method would not compile. The error is essentially \"anonymous classes cannot have static declarations\".\n\n### One Type, Not Two\n\nAn anonymous class can extend exactly one class **or** implement exactly one interface. It can't do both, and it can't implement two interfaces at once. If you need that flexibility, declare a named class.\n\n\n```shell\n// Legal:\nnew Comparator() { ... } // implements one interface\nnew Logger(\"CART\") { ... } // extends one class\n\n// Not legal as anonymous classes:\n// new Comparator(), Runnable { ... } // two interfaces: no syntax for this\n// new Logger(\"CART\") implements Runnable { ... } // class + interface: no syntax for this\n```\n\n\nThis is rarely a real-world blocker, because the situations where you'd want an inline class implementing two interfaces are uncommon. When you do hit it, the answer is to extract a named class.\n\n### A Quick Summary of the Limits\n\n\n| Limit | What it means |\n| --- | --- |\n| No named constructor | Use an instance initializer block to set up state. |\n| No static methods, no non-constant static fields | The class has no callable name from outside. |\n| Only one supertype | Pick one class or one interface. No combinations. |\n| Can't be reused | The class has no name; each `new ... { ... }` expression is a different class. |\n| Cannot capture mutable locals | Captured locals must be final or effectively final. |\n\n\n---\n\n# Anonymous Classes vs Lambdas\n\nWhen the anonymous class implements a functional interface (one abstract method), Java 8 and later let you replace it with a lambda. The lambda form is shorter and avoids the synthetic class file in most cases. The sort example from earlier looks like this with a lambda:\n\n\n```java\nCollections.sort(cart, (a, b) -> Double.compare(a.price, b.price));\n```\n\n\nThat's one line instead of five.\n\nThat said, anonymous classes are still useful in three situations:\n\n- **You're implementing an abstract class**, not an interface. Lambdas only work for functional interfaces.\n- **You need to override more than one method**, or override a method on top of providing a new one. Lambdas can only define one method.\n- **You need fields or instance state inside the implementation.** Lambdas don't have their own fields; they only capture from the enclosing scope.\n\nIf none of those apply and the interface has a single abstract method, prefer a lambda. If any of them apply, use an anonymous class.\n\nA side-by-side comparison for the comparator case.\n\n\n| Aspect | Anonymous class | Lambda |\n| --- | --- | --- |\n| Syntax length | Several lines | One line |\n| Generates a class file | Yes (`Outer$1.class`) | No, uses `invokedynamic` |\n| `this` inside | The anonymous instance | The enclosing instance |\n| Can have fields | Yes | No |\n| Works with interfaces | Any number of methods | Single abstract method only |\n| Works with abstract classes | Yes | No |\n\n\nThe table is a quick decision tool: when the right column doesn't fit your case, the left column still does.\n\n---\n\n# A Worked Example\n\nTo pull the pieces together, here's a program that uses anonymous classes in two different ways: once to provide a custom sort order, and once to register a one-off event listener.\n\n\n```java\nimport java.util.ArrayList;\nimport java.util.Collections;\nimport java.util.Comparator;\nimport java.util.List;\n\npublic class CheckoutDemo {\n interface OrderEventListener {\n void onOrderPlaced(int orderId, double total);\n }\n\n static class Product {\n String name;\n double price;\n int rating;\n Product(String name, double price, int rating) {\n this.name = name;\n this.price = price;\n this.rating = rating;\n }\n }\n\n public static void main(String[] args) {\n List cart = new ArrayList<>();\n cart.add(new Product(\"Headphones\", 49.99, 4));\n cart.add(new Product(\"USB Cable\", 9.99, 5));\n cart.add(new Product(\"Wireless Mouse\", 29.99, 5));\n\n // 1. Sort by rating descending using an anonymous Comparator.\n Collections.sort(cart, new Comparator() {\n @Override\n public int compare(Product a, Product b) {\n return Integer.compare(b.rating, a.rating);\n }\n });\n\n System.out.println(\"Sorted by rating:\");\n for (Product p : cart) {\n System.out.println(\" \" + p.name + \" (\" + p.rating + \" stars)\");\n }\n\n // 2. Register an order listener that captures a local variable.\n String storeName = \"AlgoMart\";\n\n OrderEventListener listener = new OrderEventListener() {\n @Override\n public void onOrderPlaced(int orderId, double total) {\n System.out.println(storeName + \" confirms order \" + orderId + \" for $\" + total);\n }\n };\n\n double cartTotal = 0;\n for (Product p : cart) {\n cartTotal += p.price;\n }\n listener.onOrderPlaced(1042, cartTotal);\n }\n}\n```\n\n\nTwo anonymous classes, two roles. The first one implements `Comparator` for a one-time sort. The second implements `OrderEventListener` and captures the local `storeName`, which is effectively final because it's never reassigned. Neither anonymous class deserves a separate file with its own name, and pulling them inline keeps the logic right next to the call site that needs it.","pageType":"java"}

Anonymous Classes

Get Premium