web-dev-qa-db-fra.com

Comment instanceof fonctionnera sur une interface

instanceof peut être utilisé pour tester si un objet est une instance directe ou descendante d'une classe donnée. instanceof peut également être utilisé avec des interfaces même si les interfaces ne peuvent pas être instanciées comme des classes. Quelqu'un peut-il expliquer comment fonctionne instanceof?

javainterfaceinstanceof
39
developer

Tout d’abord, nous pouvons stocker instances de classes qui implémentent une interface particulière dans un interface reference variable comme celui-ci.

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 que toute instance d'exécution qui implémente une interface particulière passera le test instanceof

MODIFIER

et la sortie

instanceof succeeded
instanceof succeeded

@RohitJain 

Vous pouvez créer des instances d'interfaces en utilisant des classes internes anonymes comme celle-ci.

Runnable runnable = new Runnable() {

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

et vous testez l'instance est de type interface, en utilisant l'opérateur instanceof comme celui-ci

System.out.println(runnable instanceof Runnable);

et le résultat est "vrai"

51
sunil

object instanceof object_interface donnera true.

14
SomeWittyUsername

Vous faites une vérification instanceof d'une reference par rapport à une instance et il vérifie le type de instance que cette reference particulière désigne.

Maintenant, puisque vous pouvez créer une référence de interface, qui pointe vers une instance mettant en œuvre class (même concept que, Super class reference pointant vers subclass instance). Vous pouvez donc vérifier instanceof.

Par exemple: -  

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.
    }
}
5
Rohit Jain

- Tout d'abord, instanceof est utilisé pour comparer si la variable de référence d'objet contenant l'objet est d'un certain type ou non.

Par exemple: 

public void getObj(Animal a){       // a is an Object Reference Variable of type Animal

    if(a instanceof Dog){


       }

}

- Dans le cas de interface, la class que implémente peut être utilisée avec instanceof.

Par exemple: 

public interface Brush{

  public void Paint();
}

public class Strokes implements Brush{

       public void Paint(){

          System.out.println("I am painting");

    }


}

public class Test{


  public static void main(String[] args){

          Brush b = new Strokes();

         if(b instanceof Strokes){


           b.Paint();
       }
  }

}
2
Kumar Vivek Mitra

hi Le ci-dessous donnera True pour l'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

2
Sumit Sagar
public class Programmers {

    public static boolean hasReallife(Programmer programmer) {
        return programmer instanceof Reallife; ══════════════════╗
    }                                                            ║
                                                                 ║
}                                                                ║
                                                                 ▼
public class ReallifeProgrammer extends Programmer implements Reallife {

    public ReallifeProgrammer() {
        diseases.get("Obesity").heal();
        diseases.get("Perfectionism").heal();
        diseases.get("Agoraphobia").heal();
    }

    @Override
    public void goOut() {
        house.getPC().shutDown();
        wife.argue();
    }

    @Override
    public void doSports() {
        goOut();
        BigWideWorld.getGym("McFit").visit();
    }

    @Override
    public void meetFriends() {
        goOut();
        BigWideWorld.searchFriend().meet();
    }

}
2
BinaryJulian

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

Si o instanceof t renvoie true, alors t castedObj = (t) o; ne lancera pas ClassCastException et castedObj ne sera pas null.

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

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

0
Jai