Anonymous classes

An anonymous class creates and defines a one-off subclass or implementation right where it is used: new Runnable() { public void run() { ... } }. Lambdas replace most of them.

A mental model

Writing a custom one-time order on a napkin instead of adding a new dish to the menu.

How it works

The new Type() { ... } expression both declares an unnamed class (extending the class or implementing the interface Type) and creates one instance of it.

The body can override methods, add fields and use final or effectively final local variables of the surrounding method.

When the type is an interface with exactly one abstract method, a lambda does the same in one line. Anonymous classes remain necessary for abstract classes, interfaces with several methods, or when you need this to mean the new object.

Going deeper

this inside an anonymous class is the anonymous object; inside a lambda this is the enclosing object. That difference decides which to use when the callback needs to refer to itself, for example to remove a listener.

Each anonymous class is a separate class file and loaded class. A non-static context also captures this, so a long-lived anonymous object can keep its whole outer object alive.

Under the hood

The compiler generates a class named Outer$1 with a constructor that receives the captured variables and the outer instance as hidden parameters.

Common mistakes

• Capturing a loop variable that is not effectively final.
• Leaking the enclosing activity or service by registering an anonymous listener and never removing it.
• Writing a ten-line anonymous class where a named class or lambda would read better.