web-dev-qa-db-fra.com

A quoi sert l'opérateur 'instanceof' en Java?

À quoi sert l'opérateur instanceof? J'ai vu des trucs comme

if (source instanceof Button) {
    //...
} else {
    //...
}

Mais cela n’a aucun sens pour moi. J'ai fait mes recherches, mais je n'ai cité que des exemples sans aucune explication.

javainstanceof
143
Ben

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

Imaginer:

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 sur-type de Dog et peut-être moins "raffiné".

Et,

dog instanceof Cat // does not even compile!

En effet, Dog n'est ni un sous-type ni un sur-type de Cat et ne l'implémente pas non plus.

Notez que la variable utilisée pour dog ci-dessus est de type Object. Ceci montre que instanceof est une opération runtime et nous amène au cas d'utilisation: pour réagir différemment en fonction du type d'objet à l'exécution .

Choses à noter: expressionThatIsNull instanceof T est faux pour tous les types T.

Bonne codage.

214
user166390

C'est un opérateur qui retourne vrai si le côté gauche de l'expression est une instance de le nom de la classe du côté droit.

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

instanceof est un outil utile lorsque vous avez une collection d'objets et que vous n'êtes pas sûr de leur nature. Disons que vous avez une collection de contrôles sur un formulaire. Vous voulez lire l'état de toutes les cases cochées, mais vous ne pouvez pas demander à un ancien objet simple de vérifier son état. Au lieu de cela, vous verriez si chaque objet est une case à cocher, et si c'est le cas, convertissez-le en case à cocher et vérifiez ses propriétés.

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

Comme décrit sur ce site :

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

if (objectReference instanceof type)

Un exemple rapide:

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

Cependant, en appliquant instanceof sur une variable/expression de référence null renvoie faux.

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

Puisqu’une sous-classe est un «type» de sa super-classe, vous pouvez utiliser le instanceof pour vérifier ceci ...

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 ça aide!

28
fireshadow52

Cet opérateur vous permet de déterminer le type d'un 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
14
Purendra Agrawal

Si source est une variable object, instanceof permet de vérifier s'il s'agit ou non d'une Button.

14
Daniel A. White

Comme mentionné dans d'autres réponses, l'usage typique canonique de instanceof est de vérifier si un identifiant fait référence à 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
}

Notez 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, la compilation suivante échouera:

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

Cela ne parvient pas à compiler 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 une classe parente de String. OTOH, cela compile parfaitement et affiche 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); 
    }
}
3
Adam Parkin

La plupart des gens ont correctement expliqué le "quoi" de cette question mais personne n'a expliqué correctement le "comment".

Alors, voici 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

Les 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 de compilation lors de la comparaison de 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 une instance d'une classe qui implémente une interface particulière.

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

Comment utiliser ensuite instanceof?
Étant donné que chaque classe s'étend d’objet, le transtypage de type LHS en objet travaillera 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");

Les sorties:

Not an instance of StringBuffer
1
sziraqui

Peut être utilisé comme un raccourci dans le contrôle d'égalité. 

Donc ce code

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

Peut être écrit comme

if(ob instanceOf ClassA) {
}
1
mirmdasif
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 

    }
}
1
bangbang

L'instance de mot clé est utile lorsque vous souhaitez connaître l'instance d'un objet particulier.

Supposons que vous soyez une exception et que lorsque vous avez catch, effectuez une opération de somme personnalisée, puis continuez selon votre logique (lancers ou journal, etc.)

Exemple: 1) L’exception personnalisée "InvalidExtensionsException" créée par l’utilisateur et renvoyée selon la logique

2) Maintenant dans le bloc catch Catch (exception e) { effectuer la somme logique 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 une exception de pointeur NULL, votre code sera cassé.

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

L'exemple ci-dessus est une mauvaise pratique de codage. Cependant, cet exemple vous aide à comprendre l'utilisation de l'instance de celle-ci.

0
vaquar khan

L'opérateur instanceof compare un objet au 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 une instance d'une classe qui implémente une interface particulière. 

http://download.Oracle.com/javase/tutorial/Java/nutsandbolts/op2.html

0
Benjamin Udink ten Cate