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();