How to Call a Newly Defined Method from an Anonymous Class in Java?

How can I call a newly defined method from an anonymous class in Java?

public interface Greeting {
    void sayHello();
}

public class Main {
    public static void main(String[] args) {
        Greeting greeting = new Greeting() {
            public void sayHello() {
                System.out.println("Hello, World!");
            }
            public void newMethod() {
                System.out.println("New Method Called");
            }
        };
        greeting.sayHello(); // Calling inherited method
        // Uncommenting the following line will cause an error, as newMethod is not accessible here.
        // greeting.newMethod();
    }
}

In Java, anonymous classes allow you to define classes at the point of instantiation, often used to implement abstract classes or interfaces. However, one limitation arises when you want to call newly defined methods specific to the anonymous class, since these methods are not part of the interface or parent class the anonymous class extends or implements.

Greeting greeting = new Greeting() {
    public void sayHello() {
        System.out.println("Hello, World!");
    }
    public void newMethod() {
        System.out.println("New Method Called");
    }
};

// Accessing the newMethod requires a cast:
((MyAnonymousClass) greeting).newMethod();

Causes

• Anonymous classes do not have their own type in Java. Hence, methods defined within an anonymous class cannot be directly called unless they are declared in a relevant interface or parent class.
• The scope of methods within an anonymous class is limited to the anonymous instance itself, making them inaccessible through references of the interface or super class.”

Solutions

• Cast the anonymous class instance to its actual type to access newly defined methods: This requires a non-abstract class.
• Define an outer class method to encapsulate the behavior as needed. But this limits the benefits of using an anonymous class.

Mistake: Trying to call a method directly on an interface type reference that is not declared in the interface.

Solution: Always ensure that methods called on an interface reference are defined within that interface.

Mistake: Not casting the reference to the specific anonymous class type to access newly defined methods.

Solution: Create a concrete class to hold common methods, or correctly cast the reference to the anonymous type.