Java cast interface to class

Question

I have a question about interface and class implementing interface.

This is my code:

interface iMyInterface {
    public iMethod1();
}

public class cMyClass implements iMyInterface {
    public iMethod1() {
        // some code
    }
    protected iMethod2() {
        // some code
    }
}

I would like to create an instance of iMyInterface as this :

iMyInterface i = new cMyClass();
i.iMethod1();

It's ok, but how can I call iMethod2() from my interface instance? Is this working and safe:

((cMyClass)i).iMethod2();

Thanks for help.

Answer 1

Yes, that will work (if you change the declaration of cMyClass to implement iMyInterface) and it's safe so long as the reference really does refer to an instance of cMyClass.

However, it's a generally bad idea. The whole point of using an interface is to be able to work with any implementation - it's to separate the abstraction from the implementation. If you're then going to require a specific implementation, you might as well make the type of i just cMyClass to start with.

So suppose instead of calling the cMyClass constructor yourself, you receive a method parameter of type iMyInterface - it's a bad idea to cast to cMyClass at that point, as it could be a different implementation of the interface.

(On a separate note, it's a good idea to start following Java naming conventions, which state that classes and interfaces should be Pascal-cased - so ditch the c and i prefixes.)

Answer 2

There is some another alternative to cast Interface to a class. Here is example how.

interface iMyInterface {
   void iMethod1();
}

public class cMyClass implements iMyInterface {

private iMyInterface myInterface;

public cMyClass() {
    myInterface = this;
}

public void iMethod1(){
    System.out.println("Print from cMyClass iMethod1()");
}

protected void iMethod2() {
    System.out.println("Print from cMyClass iMethod2()");
}

/**
 * Getter so we can access to the interface methods.
 * @return
 */
public iMyInterface getMyInterface() {
    return myInterface;
}
}

And to get values from your interface, here is the code example.

public class Main {
public static void main(String[] args) {

    cMyClass myClass = new cMyClass();
    myClass.getMyInterface().iMethod1();
    myClass.iMethod2();
}
}

Output:

Print from cMyClass iMethod1()

Print from cMyClass iMethod2()

I think this is a good example how you can separate interface code from the class code. Just create instance of the interface and every method use through getter with that interface.

Answer 3

It will work (provided that cMyClass implements iMyInterface and you are in scope of protected modifier) but that is not the correct OO approch.

If you want to use iMethod2 consider:

• adding it to the interface
• create another interface containing that method
• Use cMyClass myClass = new cMyClass();