Java - Adding methods to interface implementation

I'll use an easy example for the sake of the question.

If I have an Interface say Animal which is like

public interface Animal {
    void jump();
}

And I'm creating an object of the interface on the go, like

public class Main {
    public static void main(String[] args) {
        
        Animal cat = new Animal() {
            @Override
            public void jump() {
                System.out.println("The cat jumped");
            }

            public void sleep() {
                System.out.println("The cat slept");
            }
        };
        cat.jump(); 
        cat.sleep(); // cannot do that. 
    }
}

Now, I added the sleep() method to the interface implementation and want that method to be callable from the place where I'm calling cat.jump(). That is what I want. I see that throws an error and I do understand because the object is of type Animal and Animal does not have the sleep() method.

If I do not want to add a new method to the interface, in that case, what other options do I have to be able to call a method that I created in interface implementation?

The problem is that you didn't understand what it is to program for the interface. I believe you are thinking that it is a rule that you have created and must follow. It is not. It is something to understand why it exists and to do it when necessary.

You must declare a variable as the interface if you only need what is in the interface. If you need what is in the concrete class then you must declare the concrete class.

Casting or something else is adopting a mistake to fix the first mistake.

Interfaces should be used to segregate responsibilities. You program to interface so that what will receive the object can only access what is in that type. It is purposeful that it does not allow other members of the concrete object to access. If you used the interface, that code does not know what is not in the interface.

Do you still want to call didSomething () and be through an interface? You have two possibilities:

• Create a new interface with this method and there you can declare the variable with the type of the interface, access the desired method, and you will be programming for the interface. I consider this the most appropriate, but it may not be, in an abstract example like this, everything is possible;
• Place the method in the existing interface and you will be able to access it. It may not be what you want, but it is a possibility. I don't know what you want, the names used don't indicate what it should be.

In fact, although it is useful to see how it works, programming for interface in something as simple as that is of no practical use. It is useful to use this technique when you have complex systems, which will need maintenance and flexibility to change the implementation without having to change the contract.

interface Something {
    void doSomething();
}

interface Otherthing {
    void doOtherthing();
}

class Whatever implements Something, Otherthing {
    public void doSomething() {
       System.out.println("Do something !");
    }     
    public void doOtherthing() {
       System.out.println("Do otherthing !");
    }
}

class Test {
    public static void main(String[] arguments) {
        Something s = new Whatever();
        s.doSomething();
        Otherthing w = new Whatever(); 
        w.doOtherthing();
    }
}

If you want to call a method that's not in the interface, then you can't use the interface to make the call, you have to use the class.

Since the class is anonymous, you can't use the class.

Make a real named class, instead of using anonymous classes, e.g. create a class Cat.

class Cat implements Animal {
    // methods from anonymous class here
}

Cat cat = new Cat();
cat.jump();
cat.sleep(); // you can do this now

When you use the following syntax:

SuperClass anonymousInstance = new SuperClass() {
   /*Code here*/
}

you are not creating an instance of the Superclass (in this case, Animal). Rather, you are creating an instance of some unspecified Subclass of the Superclass. The only reason why you are able to store it in a reference variable of the Superclass is because of polymorphism.

You should only be using anonymous inner classes, as opposed to creating and instantiating an actual class, when you want to override a single method in the Superclass and only intend to use the new class once. If you are creating a new method, as you did here with the sleep method, it is better practice to create an actual class.

With that being said, if you must use an anonymous inner class and you are using Java 10 or later, you do have the option of using local variable type inference. This is accomplished via the var keyword.

var anonymousInstance = new SuperClass() {
   /*Code here*/
}

In you use the var keyword instead, the Java compiler will infer the anonymous type of the Subclass, which will include all of the methods in the Subclass. This does have its limitations - you'll lose access to new methods if you pass the object as a parameter - but it will work otherwise.