All 15 Inner Classes & Anonymous Classes questions
More in Inner Classes & Anonymous Classes
Can a local class or anonymous class be generic, and how does its own type parameter interact with any generic type parameters already declared on its enclosing class or method? How would you access the enclosing outer class's instance from within a nested inner class when there's a naming conflict (like a shadowed field with the same name), using the OuterClassName.this syntax? How do local classes (defined within a method body) and anonymous classes differ in their capabilities and use cases, particularly regarding capturing local variables and reusability? How does the compiler implement inner classes at the bytecode level, and what synthetic elements (like a hidden outer-class reference field and synthetic accessor methods) does it generate to make this work? How would you use a local class defined within a method to implement a fairly complex, stateful callback that needs multiple methods and constructor parameters, where a lambda expression genuinely wouldn't suffice? How would you implement the classic Iterator design pattern using a private non-static inner class, letting the inner Iterator implementation access the outer collection's private internal state directly? How would you decide between using a static nested class, a non-static inner class, a local class, an anonymous class, or a lambda expression for a given design scenario, weighing their respective trade-offs?
Advertisement
Java › Inner Classes & Anonymous Classes

How would you use an anonymous class to create a one-off subclass with a customized implementation, distinct from anonymous classes implementing an interface, and what specific syntax quirk applies?

Advanced

Answer

An anonymous class can also extend a concrete (or abstract) class rather than implementing an interface, providing an inline, one-off subclass with overridden or additional behavior specific to just that single usage site -- the syntax is `new SuperClass(constructorArgs) { ... overrides/additions ... }`, distinct from the interface-implementing form only in that constructor arguments can be passed to the superclass's constructor (since there IS an actual superclass constructor being invoked, unlike implementing a pure interface which has no constructor at all).
public abstract class Shape {
    abstract double area();
    Shape(String name) { System.out.println("Created: " + name); }
}

Shape customShape = new Shape("CustomCircle") {  // anonymous SUBCLASS, passing a constructor argument
    double radius = 5.0;
    @Override
    double area() { return Math.PI * radius * radius; }
};
System.out.println(customShape.area());
Real-world example A test suite creates a one-off anonymous subclass of an abstract HttpResponse class specifically to override just the getStatusCode() method for a single specific test case, avoiding the need to define and maintain an entirely separate, permanently-named test-double class file just for that one narrow test scenario.

Common follow-ups: Can an anonymous class extending a concrete class add entirely new public methods callable from outside, or are its capabilities limited to what the reference type's static type allows?;Why can't an anonymous class have an explicit, named constructor of its own?

OOP & Classes;Testing Strategy
All 15 Inner Classes & Anonymous Classes questions