Anonymous Class

An anonymous class in Java is an inner class without a declared name that is defined and instantiated in a single expression. It acts as an inline implementation of an interface or an inline subclass of an existing class, allowing developers to override methods or implement abstract behaviors directly at the point of object creation. According to the Java Language Specification, anonymous classes are a distinct category of inner classes; unlike local classes, which have names and are declared within blocks, anonymous classes lack names and are declared within expressions.

Syntax

The syntax combines object instantiation with a class declaration body.

// 1. Implementing an Interface
InterfaceType instance1 = new InterfaceType() {
    // Instance variables
    private int state;

    // Instance initializer (acts as a constructor)
    {
        state = 0;
    }

    @Override
    public void requiredMethod() {
        // Implementation details
    }
};

// 2. Extending a Class and utilizing local variable type inference (Java 10+)
var instance2 = new SuperClassType(constructorArgument) {
    @Override
    public void existingMethod() {
        // Overridden implementation details
    }
    
    // New method, accessible because 'var' captures the non-denotable type
    public void helperMethod() {
        // Implementation details
    }
};

Technical Characteristics

• Inheritance Constraints: An anonymous class can either implement exactly one interface or extend exactly one class. It cannot do both simultaneously, nor can it implement multiple interfaces.
• Constructor Absence: Because the class has no name, it cannot declare explicit constructors. Initialization logic must be placed inside an instance initializer block ({ ... }). If the anonymous class extends a superclass, arguments passed to the new expression are automatically routed to the matching superclass constructor.
• Polymorphism and Type: Traditionally, the reference type holding the anonymous class instance must be the declared supertype (the interface or the superclass). Under this constraint, any new methods or fields declared inside the anonymous class body cannot be invoked from the outside reference. However, since Java 10, if the instance is assigned to a local variable using var, the compiler infers the non-denotable anonymous class type. This allows direct invocation of its newly defined methods (e.g., instance2.helperMethod();).

Lexical Scoping and Variable Capture

Anonymous classes are subject to specific scoping rules regarding their enclosing environment:

• Enclosing Class Members: They have unrestricted access to all members (fields and methods) of their enclosing class, including those marked private, provided the anonymous class is created within an instance context. If the anonymous class is instantiated within a static context (such as a static method or static initializer block), it has no enclosing instance and therefore cannot access non-static instance members of the enclosing class.
• Shadowing: Declarations of types, variables, or methods within the anonymous class shadow declarations in the enclosing scope that share the same name.
• Effectively Final Requirement: If an anonymous class accesses local variables or parameters from its enclosing block (such as a method body), those variables must be declared final or be effectively final. An effectively final variable is one whose value is never modified after its initial assignment. The compiler enforces this to prevent concurrency issues and lifecycle mismatches between the local stack frame and the heap-allocated anonymous instance.

Compilation Artifacts

The Java compiler does not inline anonymous classes. Instead, it generates a distinct bytecode file (.class) for every anonymous class at compile time.

The compiler assigns a synthetic name to the class using the pattern OuterClassName$N.class, where N is a sequential, 1-based integer representing the order in which the anonymous classes appear in the source file. For example, the first anonymous class inside NetworkManager will be compiled to NetworkManager$1.class.

Master Java with Deep Grasping Methodology!

Learn More