Dans quel cas l'opérateur' instanceof ' est-il utilisé en Java?

instanceof mot-clé est un opérateur binaire utilisé pour tester si un objet (exemple) est un sous-type d'un Type donné.

Imaginez:

interface Domestic {}
class Animal {}
class Dog extends Animal implements Domestic {}
class Cat extends Animal implements Domestic {}

Imaginez un dog objet , créé avec Object dog = new Dog() , puis:

dog instanceof Domestic // true - Dog implements Domestic
dog instanceof Animal   // true - Dog extends Animal
dog instanceof Dog      // true - Dog is Dog
dog instanceof Object   // true - Object is the parent type of all objects

cependant, avec Object animal = new Animal(); ,

animal instanceof Dog // false

parce que Animal est un supertype de Dog et peut-être moins "raffiné".

et,

dog instanceof Cat // does not even compile!

c'est parce que Dog n'est ni un sous-Type ni un super-type de Cat , et il ne l'applique pas non plus.

noter que la variable utilisée pour dog ci-dessus est du type Object . C'est pour montrer instanceof est un runtime opération et nous amène à un/des cas d'utilisation: réagir différemment selon un type d'objet à l'exécution .

choses à noter: expressionThatIsNull instanceof T est faux pour tous les Types T .

Heureux de codage.

c'est un opérateur qui renvoie true si le côté gauche de l'expression est une instance de le nom de classe sur le côté droit.

Pensez-y de cette façon. Dites que toutes les maisons de votre quartier ont été construites à partir des mêmes plans. Dix maisons (objets), un ensemble de plans (définition de classe).

instanceof est un outil utile quand vous avez une collection d'objets et vous n'êtes pas sûr de ce qu'ils sont. Disons que vous avez obtenu une collection de contrôles sur un formulaire. Vous voulez lire l'état vérifié de toutes les cases à cocher, mais vous ne pouvez pas demander à un simple vieil objet son état vérifié. Au lieu de cela, vous verriez si chaque objet est une case à cocher, et si c'est le cas, jetez-le dans une case à cocher et vérifiez ses propriétés.

if (obj instanceof Checkbox)
{
    Checkbox cb = (Checkbox)obj;
    boolean state = cb.getState();
}

comme décrit sur ce site :

l'opérateur instanceof peut être utilisé pour tester si un objet est type spécifique...

if (objectReference instanceof type)

un exemple rapide:

String s = "Hello World!"
return s instanceof String;
//result --> true

cependant, appliquer instanceof sur une variable/expression de référence nulle renvoie la valeur false.

String s = null;
return s instanceof String;
//result --> false

étant donné qu'une sous-classe est un "type" de sa superclasse, vous pouvez utiliser l' instanceof pour vérifier...

class Parent {
    public Parent() {}
}

class Child extends Parent {
    public Child() {
        super();
    }
}

public class Main {
    public static void main(String[] args) {
        Child child = new Child();
        System.out.println( child instanceof Parent );
    }
}
//result --> true

j'espère que cela aidera!

si source est une variable object , instanceof est une façon de vérifier si elle est une Button ou non.

cet opérateur vous permet de déterminer le type d'objet. Il renvoie une valeur boolean .

par exemple

package test;

import java.util.Date;
import java.util.Map;
import java.util.HashMap;

public class instanceoftest
{
    public static void main(String args[])
    {
        Map m=new HashMap();
        System.out.println("Returns a boolean value "+(m instanceof Map));
        System.out.println("Returns a boolean value "+(m instanceof HashMap));
        System.out.println("Returns a boolean value "+(m instanceof Object));
        System.out.println("Returns a boolean value "+(m instanceof Date));
    }
} 

la sortie est:

Returns a boolean value true
Returns a boolean value true
Returns a boolean value true
Returns a boolean value false

comme mentionné dans d'autres réponses, l'usage canonique typique de instanceof est pour vérifier si un identificateur se réfère à un type plus spécifique. Exemple:

Object someobject = ... some code which gets something that might be a button ...
if (someobject instanceof Button) {
    // then if someobject is in fact a button this block gets executed
} else {
    // otherwise execute this block
}

noter cependant que le type de l'expression de gauche doit être un type parent de l'expression de droite (voir JLS 15.20.2 et Java Puzzlers, #50, pp114 ). Par exemple, les suivants ne pourront pas compiler:

public class Test {
    public static void main(String [] args) {
        System.out.println(new Test() instanceof String); // will fail to compile
    }
}

cela ne colle pas avec le message:

Test.java:6: error: inconvertible types
        System.out.println(t instanceof String);
                       ^
  required: String
  found:    Test
1 error

Comme Test n'est pas un parent de la classe de String . OTOH, cela se compile parfaitement et imprime false comme prévu:

public class Test {
    public static void main(String [] args) {
        Object t = new Test();
        // compiles fine since Object is a parent class to String
        System.out.println(t instanceof String); 
    }
}

cet opérateur n'est utilisé que pour les variables de référence d'objet. L'opérateur vérifie si l'objet est d'un type particulier (type de classe ou de type d'interface). instanceof opérateur est écrit comme:

( Object reference variable ) instanceof  (class/interface type)

si l'objet désigné par la variable du côté gauche de l'opérateur passe la vérification" IS-a " pour le type de classe/interface du côté droit, alors le résultat sera vrai.

public class Animal{ float age; }

public class Lion extends Animal { int claws;}

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

        Animal animal = new Animal(); 
        Animal animal2 = new Lion(); 
        Lion lion = new Lion(); 
        Animal animal3 = new Animal(); 
        Lion lion2 = new Animal();   //won't compile (can't reference super class object with sub class reference variable) 

        if(animal instanceof Lion)  //false

        if(animal2 instanceof Lion)  //true

        if(lion insanceof Lion) //true

        if(animal3 instanceof Animal) //true 

    }
}

peut être utilisé comme un raccourci dans le contrôle de l'égalité.

donc ce code

if(ob != null && this.getClass() == ob.getClass) {
}

peut s'écrire comme

if(ob instanceOf ClassA) {
}

l'instanceof operator compare un objet à un type spécifié. Vous pouvez l'utiliser pour tester si un objet est une instance d'une classe, une instance d'une sous-classe ou d'une instance d'une classe qui implémente une interface particulière.

http://download.oracle.com/javase/tutorial/java/nutsandbolts/op2.html

Instance de mot-clé est utile lorsque vous voulez connaître l'instance d'un objet particulier .

supposez que vous êtes exception jeter et quand vous avez attraper alors effectuer la somme opération personnalisée et puis de nouveau continuer comme selon votre logique (lancers ou log etc)

exemple : 1) l'exception personnalisée créée par L'utilisateur "InvalidExtensionsException" et la jeter selon la logique

2) maintenant dans le bloc de capture captures (Exception e)) { exécuter la logique de somme si le type d'exception est "InvalidExtensionsException "

InvalidExtensionsException InvalidException =(InvalidExtensionsException)e;

3) Si vous ne Vérifiez pas l'instance de et que le type d'exception est Null pointeur exception votre code se casse.

donc votre logique devrait être à l'intérieur de l'instance de si (e instanceof InvalidExtensionsException){ InvalidExtensionsException InvalidException =(InvalidExtensionsException) e; }

l'exemple ci-dessus est une mauvaise pratique de codage mais cet exemple est vous aider à comprendre l'utilisation de l'instance.

la plupart des gens ont correctement expliqué le" Quoi "de cette question, mais personne n'a expliqué le" Comment " correctement.

voici donc une illustration simple:

String s = new String("Hello");
if (s instanceof String) System.out.println("s is instance of String"); // True
if (s instanceof Object) System.out.println("s is instance of Object"); // True
//if (s instanceof StringBuffer) System.out.println("s is instance of StringBuffer"); // Compile error
Object o = (Object)s;
if (o instanceof StringBuffer) System.out.println("o is instance of StringBuffer"); //No error, returns False
else System.out.println("Not an instance of StringBuffer"); // 
if (o instanceof String) System.out.println("o is instance of String"); //True

sorties:

s is instance of String
s is instance of Object
Not an instance of StringBuffer
o is instance of String

la raison de l'erreur du compilateur en comparant s avec StringBuffer est bien expliquée dans docs :

Vous pouvez l'utiliser pour tester si un objet est une instance d'une classe, une instance d'une sous-classe ou d'une instance d'une classe qui implémente une interface particulière.

, ce qui implique que le LHS doit être une instance de RHS ou D'une classe qui implémente RHS ou étend RHS.

comment utiliser use instanceof then?

Puisque chaque classe étend L'objet, le type-casting LHS à l'objet fonctionnera toujours en votre faveur:

String s = new String("Hello");
if ((Object)s instanceof StringBuffer) System.out.println("Instance of StringBuffer"); //No compiler error now :)
else System.out.println("Not an instance of StringBuffer");

sorties:

Not an instance of StringBuffer

vous pouvez utiliser la carte pour faire une abstraction plus élevée sur l'instance de

private final Map<Class, Consumer<String>> actions = new HashMap<>();

alors ayant une telle carte ajouter une certaine action à elle:

actions.put(String.class, new Consumer<String>() {
        @Override
        public void accept(String s) {
           System.out.println("action for String");       
        }
    };

ayant alors un objet de type inconnu, vous pourriez obtenir une action spécifique à partir de cette carte:

actions.get(someObject).accept(someObject)

class Test48{
public static void main (String args[]){
Object Obj=new Hello();
//Hello obj=new Hello;
System.out.println(Obj instanceof String);
System.out.println(Obj instanceof Hello);
System.out.println(Obj instanceof Object);
Hello h=null;
System.out.println(h instanceof Hello);
System.out.println(h instanceof Object);
}
}  

exemple de code très simple:

If (object1 instanceof Class1) {
   // do something
} else if (object1 instanceof Class2) {
   // do something different
}

faites attention. Dans l'exemple ci-dessus, si Class1 est Objet de la première comparaison sera toujours vrai. Donc, comme avec des exceptions, l'ordre hiérarchique est important!

l'opérateur instanceof permet de vérifier si l'objet est une instance du type spécifié. (classe ou sous-classe ou interface).

l'instanceof est également connu sous le nom d'opérateur de comparaison de type parce qu'il compare l'instance avec le type. Elle renvoie vrai ou faux.

class Simple1 {  
public static void main(String args[]) {  
Simple1 s=new Simple1();  
System.out.println(s instanceof Simple1); //true  
}  
}  

si nous appliquons l'instanceof operator avec une variable qui a une valeur nulle, elle renvoie false.