Extending Classes with Anonymous Classes
In this lesson, you'll learn how to create anonymous subclasses that override methods of both concrete and abstract classes.
Core Concept
You already know how to implement interfaces with anonymous classes. But anonymous classes are even more versatile—they can also extend regular classes (concrete) or abstract classes, allowing you to create one-off subclasses that override specific methods right where you need them.
The syntax is nearly identical to implementing interfaces: you use new ClassName() followed by curly braces containing your overridden methods.
Extending Concrete Classes
When you extend a concrete class anonymously, you're creating an unnamed subclass on the spot:
class Greeter {
void greet() {
System.out.println("Hello");
}
}
Greeter friendly = new Greeter() {
@Override
void greet() {
System.out.println("Hello, friend!");
}
};
friendly.greet(); // prints: Hello, friend!
Here, you're not calling the Greeter constructor and stopping—you're defining a whole new subclass that overrides greet().
Extending Abstract Classes
Anonymous classes shine when working with abstract classes, letting you provide implementations without creating a named subclass:
abstract class Task {
abstract void execute();
}
Task myTask = new Task() {
@Override
void execute() {
System.out.println("Task running");
}
};
myTask.execute(); // prints: Task running
This is particularly useful when you need a quick, localized implementation and don't want the overhead of a separate class file.
Key Takeaway: Anonymous classes can extend both concrete and abstract classes by overriding methods inline, creating one-time-use subclasses without naming them explicitly.