Comment instanceof va travailler sur une interface

Tout d'abord, nous pouvons stocker des instances de classes qui implémente un particulier interface dans un interface reference variable comme ça.

package com.test;

public class Test implements Testeable {

    public static void main(String[] args) {

        Testeable testeable = new Test();

        //OR

        Test test = new Test();

        if (testeable instanceof Testeable)
            System.out.println("instanceof succeeded");
        if (test instanceof Testeable)
            System.out.println("instanceof succeeded");
    }
}

interface Testeable {

}

c'est à dire, tout runtime exemple qui implémente une interface particulière va passer la instanceof test

MODIFIER

et la sortie

instanceof succeeded
instanceof succeeded

@RohitJain

Vous pouvez créer des instances des interfaces en utilisant les classes internes anonymes comme ce

Runnable runnable = new Runnable() {

    public void run() {
        System.out.println("inside run");
    }
};

et vous test de l'instance est de type interface, à l'aide de instanceof opérateur comme ce

System.out.println(runnable instanceof Runnable);

et le résultat est "vrai"

Vous faire un instanceof contrôle d'un reference contre un instance, et il vérifie le type de instance que particulier reference pointe.

Maintenant, puisque vous pouvez créer une référence d'un interface, qui renvoie à une instance de mise en œuvre de class (même concept que, Super class reference pointant vers subclass instance). Ainsi, vous pouvez faire un instanceof vérifier sur elle.

Pour l'e.g :-

public interface MyInterface {
}

class ImplClass implements MyInterface {

    public static void main(String[] args) {
        MyInterface obj = new ImplClass();

        System.out.println(obj instanceof ImplClass);   //Will print true.
    }
}

salut Les ci-dessous rendement Vrai pour la instanceOf:

•   If S is an ordinary (nonarray) class, then:
    •   If T is a class type, then S must be the same class as T, or S must be a subclass of T;
    •   If T is an interface type, then S must implement interface T.
•   If S is an interface type, then:
    •   If T is a class type, then T must be Object.
    •   If T is an interface type, then T must be the same interface as S or a superinterface of S.
•   If S is a class representing the array type SC[], that is, an array of components of type SC, then:
    •   If T is a class type, then T must be Object.
    •   If T is an interface type, then T must be one of the interfaces implemented by arrays (JLS §4.10.3).
•   If T is an array type TC[], that is, an array of components of type TC, then one of the following must be true:
         - TC and SC are the same primitive type. 
         - TC and SC are reference types, and type SC can be cast to TC by these run-time rules

S'il vous plaît aller à ce lien pour avoir une idée claire:

http://docs.oracle.com/javase/specs/jvms/se7/html/jvms-6.html#jvms-6.5.instanceof

Je sais que c'est une très très vieille question avec beaucoup de bonnes réponses. Je veux juste souligner le plus facile (au moins, il est plus facile pour moi) façon de comprendre cet opérateur.

Si o instanceof t retourne true, puis
t castedObj = (t) o; ne sera pas jeter ClassCastException, et castedObj ne sera pas null.

C'est important/utile si vous souhaitez accéder à des champs ou de méthodes de castedObj plus tard - vous savez qu'en faisant le instanceof vérifier, vous n'aurez jamais de problèmes plus tard.

Le seul inconvénient est que cela peut être utilisé pour les types sans les génériques.