Anonymous Inner Class in Java, with Examples

An anonymous inner class in Java is a class with no name that you define and create an object of in one expression, by putting a class body in braces right after new and the name of an interface or class. Use one when you need a class in exactly one place, such as a one-off implementation of an interface. Every example below runs in the page: how to write one, the two ways to use it, the rules for variables and this, and when a lambda fits better.

It prints Good morning, Ada. The variable polite holds an object of a class that has no name in the code. Press Run and look at the memory view: it shows one object of class Main$1, the name the compiler gives the class behind the scenes.

How to write an anonymous class#

The general shape is new Type(arguments) { class body }. Read the example's new Greeter() { ... }; from left to right:

• new creates an object, as it always does.
• Greeter is the type the new class builds on: an interface to implement, or a class to extend.
• () holds the arguments for a constructor. An interface has no constructor, so here the parentheses stay empty.
• The braces hold the class body, written the way you write any class: fields and methods. This body has one method, greet. It is public because the methods an interface asks for are always public, and a class may not offer one with less access.
• The semicolon after the closing brace ends the statement. The whole thing is one expression inside an ordinary variable declaration.

Key idea

An anonymous class expression does two jobs at once: it declares a new class with no name, and it creates one object of that class.

Implement an interface with an anonymous class#

Implementing an interface is the most common use. You cannot write new Greeter() on its own, because Greeter leaves its method for a class to write: javac says Greeter is abstract; cannot be instantiated. Add a body that supplies the missing method, and Java has a complete class to build an object from.

Interfaces from Java's library work the same way. Comparator<String> has one method to fill in, compare, which returns a negative number, zero or a positive number to say which of two strings comes first. This one sorts fruit by the length of the name:

It prints [fig, kiwi, banana, cherry]. Integer.compare returns a negative number when a is shorter, so shorter names go first. banana and cherryboth have six letters, and they keep their original order, because Java's list sort never reorders items that compare as equal.

The empty <> after Comparator is the diamond: Java works out Stringfrom the variable's type. Anonymous classes accept the diamond since Java 9. Older code spells it out as new Comparator<String>().

Extend a class with an anonymous class#

The name after new can also be a class. The anonymous class then extends it and can override its methods. If the class is abstract (it leaves some methods unwritten, so you cannot create one directly), the anonymous class must write every missing method. If it is an ordinary class, the anonymous class overrides only what it wants to change.

It prints square has area 9.0, then count is now 1 and count is now 2. The "square" in the parentheses goes to Shape's constructor: arguments after new always go to the constructor of the class being extended. Inside the second class, super.add() runs Counter's own add first, as in any subclass. Step through it and the trace jumps into the Shape constructor while the first object is being built.

Why is it called an inner class?#

An inner class is a class written inside another class without the word static. Each of its objects belongs to one object of the outer class, the enclosing object, and can use that object's fields directly. An anonymous class written inside an instance method (a method without static, which runs on an object) is an inner class in this sense:

It prints Welcome to Crumbs, Ada!, then Welcome to Crumbs and Co, Ada!. Inside greet, nameis the bakery's field, read at the moment the method runs, so the greeter sees the new name. Step through it and look at the Bakery$1 object in the memory view: its only row is Bakery.this, a hidden link back to the bakery that created it.

The earlier examples on this page sit in main, which is static and runs on no object, so their anonymous classes have no such link. Named inner classes and static nested classes are covered in the inner classes lesson.

Using local variables: the effectively final rule#

An anonymous class can read the local variables of the method around it, as the shape example read side, but only if each one keeps a single value. Java calls such a variable effectively final: it has no final keyword, but it could have one. Give the variable a second value anywhere, inside the anonymous class or outside it, and the program no longer compiles. The usual way to hit this is counting something:

To count, keep the number in a field instead, since fields may change freely. It can be a field of the anonymous object itself, as in the next section, or a field of the enclosing object.

What an anonymous class can and cannot have#

The body can hold fields and as many methods as you like, with one exception: no constructor, since a constructor must carry the class's name. For setup, you have two options. Pass arguments to the parent class's constructor in the parentheses, as Shape did, or write an instance initializer: a bare block of code in braces inside the class body, which runs each time an object of the class is created.

It prints [ticket] machine ready first, while new builds the object, then [ticket] issued 1, A-1, [ticket] issued 2 and A-2. The field issued changes on every call, which is allowed because it belongs to the object, not to main. log is an extra method that Ticket knows nothing about, called from inside the class. The limits:

• No constructor of its own. Writing Ticket() { ... } in the body fails with invalid method declaration; return type required, because to javac it looks like a method with its return type missing.
• One parent type. It extends one class or implements one interface, never both, and never two interfaces.
• No arguments for an interface. new Ticket("A-") { ... } fails with anonymous class implements interface; cannot have arguments.
• No name to reuse. The expression can run many times, in a loop or in a method you call twice, and makes a new object of the same class each time, but no other line can create one by name. If you need the class in two places, give it a name.
• Code outside sees only the parent type. ticket.log("hi") in main fails with cannot find symbol, because ticket is a Ticket, and Ticket has no log.

Anonymous class vs lambda expression#

A lambda expression is a shorter way to create an object of a functional interface, an interface with exactly one abstract method: you write only the parameters, an arrow and the body. Lambdas arrived in Java 8, and since then most anonymous classes that implement a one-method interface have given way to lambdas. Here is the same Greeter both ways:

It prints Good morning, Ada. and Hey Ada!. The lambda leaves out new Greeter(), the method header and the braces, because the compiler can work all of them out from the variable's type.

What this means inside each one#

The this row surprises people. Decide what this program prints, then run it.

It prints anonymous class: a Speaker with no name, then lambda: Robot R2. Inside the anonymous class, this is the anonymous object, so the text comes from its own toString. A lambda does not change what this means, so inside it this is the robot, as anywhere else in test. To reach the robot from inside the anonymous class, write Robot.this.

What does :: mean in Java?#

:: makes a method reference, an even shorter lambda for when the lambda only calls a method that already exists. String::length means s -> s.length(), and System.out::println means x -> System.out.println(x). Here is the length comparator from earlier, down to one line:

It prints fig, kiwi, banana and cherry, one per line, in the same order the anonymous Comparator gave. Comparator.comparingInt builds the comparator from a rule that turns each string into a number. There are four kinds of method reference: a static method (Integer::parseInt), a method of one particular object (System.out::println), a method of whichever object is passed in (String::length), and a constructor (ArrayList::new). The lambdas lesson teaches lambdas and method references from the start.

Anonymous classes are not unnamed classes#

“Unnamed class” sounds like another word for an anonymous class, but it was the name of a different feature: a source file that holds a main method with no class written around it. Java 21 previewed it as unnamed classes (JEP 445), later previews renamed it implicitly declared classes, and Java 25 made it final as compact source files with instance main methods (JEP 512). In Java 25, a file that contains only void main() { IO.println("Hi"); } is a complete program, and Java wraps it in a class that it declares for you.

The two share only the idea of a class you never name. An anonymous class is an expression inside a program that makes one object; a compact source file is a whole program. Compact source files are where your first Java program starts.