接口类型实例来自哪个类

Question

I have an interface:

public interface Myinterface{
  ...
}

The interface is implemented by three classes, let's name them ClassOne , ClassTwo , ClassThree .

Now, I have a helper method which returns an instance of type MyInterface . eg

MyInterface myInstance = MyHelper.getOneInstance();

I what to check whether the returned instance myInstance is a instance of ClassThree or not, how to do it in Java?

(I know there is instanceof keyword in Java, but it is checking the other way around. I want to know which concrete class the instance is from.)

Answer 1

To check whether an object is an instance of a specific class, you can use the getClass() method from the Object class.

For example this is true only if myInstance is a ClassThree object:

if (myInstance.getClass() == ClassThree.class)

Now, generally this is not necessarily more robust as it defeats some of the benefits of OOP.
A more OOP way to proceed is introducing a method that you could use to do this check.

As you don't give a specific example, it is hard to give an adapted example but assume that you want to save some classes if these are recordable.
You could introduce a boolean isRecordable() method in your interface.

In this way you could do :

if (myInstance.isRecordable()){
    ...
}

Answer 2

Pretty sure instanceof ClassThree is true if getOneInstance() returns a ClassThree object.

    while (true){
        MyInterface impl = MyHelper.getOneInstance()();
        if(impl instanceof Class1){
            System.out.println("was 1");
        } else if(impl instanceof Class2){
            System.out.println("was 2");
        } else if(impl instanceof Class3){
            System.out.println("was 3");
        }
    }

The difference between instanceof and getClass() implementations is that instanceof will look up the hierarchy so

new ClassThree() instanceof MyInterface is true whereas,

new ClassThree().getClass() == MyInterface.class is false.

Answer 3

Try the visitor pattern

Often you don't want to know the implementing class name, but want to have the correct behaviour ensured. The visitor pattern is a layer of indirection, with its own pitfalls, but generally speaking often the way to go.

I think it is better than instance of because sometimes your object is an instance of different classes/interfaces and therefore your check must be considering all possible combinations and not return early. Another downside is, that if you use getClass() your code will become cluttered with if s accross your project, whereas the Visitor gives you a central place.

public interface MyVisitor<T> {
    T visitClassOne(ClassOne classOne);
    T visitClassTwo(ClassTwo classTwo);
    T visitClassThree(ClassThree classThree);
}

public interface MyInterface {
    Class acceptVisitor(MyVisitor myVisitor);
}

public class ClassOne implements MyInterface {
    @Override
    Class acceptVisitor(MyVisitor myVisitor) {
        return myVisitor.visitClassOne(this);
    }
}


//or maybe call the desired methods directly, instead of returning the 
//Class an call the desired methods based on the result. 
public class ClassVisitor implements MyVisitor<Class> {
    @Override
    Class visitClassOne(ClassOne classOne) {
        return classOne.getClass();
    }

    @Override
    Class visitClassTwo(ClassTwo classTwo) {
        return classTwo.getClass();
    }

    @Override
    Class visitClassThree(ClassThree classThree) {
        return classThree.getClass();
    }
}

so sowhere else you could do:

MyInterface myClass = new ClassOne();
Class myClassClass = myClass.acceptVisitor(new ClassVisitor());

this is untestet, I just wrote it down. I have to admit for returning Class this is not the tiptop very best idea, but as already said, often you don´t want to do that.

Answer 4

Have you tried the "is" keyword? if (myInstance is ClassThree) { . . . }