Java instanceof Keyword

Dans ce tutoriel, vous découvrirez en détail l'opérateur instanceof de Java à l'aide d'exemples.

En Java, le mot-clé instanceof est un opérateur binaire. Il est utilisé pour vérifier si un objet est une instance d'une classe spécifique.

L'opérateur vérifie également si l'objet est une instance de la classe implémentant l'interface (ce qui sera discuté plus tard dans ce tutoriel).

La syntaxe de instanceof est :

result = objectName instanceof className;

　L'opérateur instanceof est appliqué à l'opérateur de gauche, qui est le nom de l'objet, et à l'opérateur de droite, qui est le nom de la classe. Si l'objet est une instance de la classe, le résultat est true ; sinon, il est false.

Example1：instanceof

class Main {
　　　　public static void main (String[] args) {
　　　　　　　　String name = "w3codebox";
　　　　　　　　Integer age =　22;
　　　　　　　　System.out.println("name est une instance de String: "}+　(name instanceof String));
　　　　　　　　System.out.println("Est-ce une instance de Integer: ");+　(age instanceof Integer));
　　　　}
}

Output:

Est-ce une instance de String: true
Est-ce une instance de Integer: true

Dans l'exemple ci-dessus, nous avons créé un objet de type String name et un autre objet de type Integer age. Ensuite, nous avons utilisé l'opérateur instanceof pour vérifier si le nom est de type String et si l'âge est de type Integer.

instanceof et héritage

Dans le cas de l'héritage, l'opérateur instanceof est utilisé pour vérifier si l'objet de la sous-classe est également une instance de la classe supérieure.

Example2：instanceof dans l'héritage

class Animal {
}
//La classe Dog est une sous-classe de la classe Animal
class Dog extends Animal {
}
class Main {
　　　　public static void main(String[] args){
　　　　　　　　Dog d1　= new Dog();
　　　　　　　　//Vérification de d1Est-ce un objet de la classe Dog
　　　　　　　　System.out.println("d1Est-ce une instance de Dog: "+　(d1　instanceof Dog));
　　　　　　　
　　　　　　　　//Vérification de d1Est-ce un objet de la classe Animal
　　　　　　　　System.out.println("d1Est-ce une instance de Animal: "+　(d1　instanceof Animal));
　　　　}
}

Output:

d1Est-ce une instance de Dog: true
d1Est-ce une instance de Animal: true

Dans l'exemple ci-dessus, d1sont des instances des classes Dog et Animal. Par conséquent, d1 instanceof Dog et d1 instanceof Animal sont tous true.

Classe Object

En Java, toutes les classes héritent de la classe Object, l'héritage de la classe Object n'utilise pas la clause extends. Cet héritage se produit implicitement en Java.

Example3：Classe Object

class Animal {
}
class Dog {
}
class Cat {
}
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Dog d1　= new Dog();
　　　　　　　　Animal a1　= new Animal();
　　　　　　　　Cat c1　= new Cat();
　　　　　　　　System.out.println("d1Est-ce une instance de la classe Object: "+　(d1　instanceof Object));
　　　　　　　　System.out.println("a1Est-ce une instance de la classe Object: "+　(a1　instanceof Object));　　　
　　　　　　　　System.out.println("c1Est-ce une instance de la classe Object: "+　(c1　instanceof Object));
　　　　}
}

Output:

d1Est-ce une instance de la classe Object: true
a1Est-ce une instance de la classe Object: true
c1Est-ce une instance de la classe Object: true

Dans l'exemple ci-dessus, nous avons respectivement créés des objets de classes Animal, Dog et Cat: a1、d1et c1Nous avons utilisé l'opérateur instanceof pour vérifier ces objets a1, d1, c1Est-ce aussi un objet de la classe Object. Les résultats de la sortie sont tous true (vrai).

C'est parce que la classe Object est la classe racine définie dans le paquet java.lang. Toutes les autres classes sont des sous-classes de la classe Object formant une hiérarchie dans Java.

对象向上转型和向下转型

En Java, un objet de la sous-classe peut être considéré comme un objet de la classe parente. Cela s'appelle une conversion vers le haut.En termes simples, c'est convertir un objet de la sous-classe en objet de la classe parente. Ici, l'objet de la classe parente peut être une interface.

Le compilateur Java effectue automatiquement la conversion vers le haut.

Example4：对象向上转型

class Animal {
　　　　public void displayInfo() {
　　　　　　　　System.out.println("Je suis un animal.");
　　　　}
}
class Dog extends Animal {
}
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Dog d1　= new Dog();
　　　　　　　　Animal a1　= d1;
　　　　　　　　a1.displayInfo();
　　　　}
}

Output:

Je suis un animal.

Dans l'exemple précédent, nous avons créé un objet de la classe Dog d1. Nous utilisons d1Pour créer un objet de la classe Animal a1. C'est ce qui est appelé conversion vers le haut en Java.

Ce code s'exécute sans problème. C'est parce que la conversion vers le haut est effectuée automatiquement par le compilateur Java.

La conversion vers le bas est le processus opposé à la conversion vers le haut, c'est-à-dire l'inverse de la conversion vers le haut, c'est-à-dire convertir un objet de la classe parente en objet de la sous-classe.

Dans le cas de la conversion vers le bas, l'objet de la classe parente est considéré comme un objet de la sous-classe. Nous devons explicitement indiquer au compilateur Java de faire la conversion vers le bas.

Example5：问题在于对象向下转型

class Animal {
}
class Dog extends Animal {
　　　public void displayInfo() {
　　　　　　　System.out.println("Je suis un chien.");
　　　}
}
class Main {
　　　public static void main(String[] args) {
　　　　　　　Animal a1　= new Animal();
　　　　　　　Dog d1　= (Dog)a1;　//　Conversion vers le bas
　
　　　　　　　d1.displayInfo();
　　　}
}

Lors de l'exécution du programme, une exception de type ClassCastException s'affiche. Voyons ce qui se passe ici.

Ici, nous créons un objet de la classe parente Animal a1.1L'objet est forcé de se convertir en un objet de la sous-classe Dog d1.

Cela pose un problème. C'est parce que le champ a de la classe parente Animal1L'objet peut également référencer d'autres sous-classes. Si nous créons une autre sous-classe Cat avec Dog ; l'animal peut être un chat ou un chien, ce qui peut prêter à confusion.

Pour résoudre ce problème, nous pouvons utiliser l'opérateur instanceof. Voici comment faire :

Example6：使用instanceof解决向下类型转换

class Animal {
}
class Dog extends Animal {
　　public void displayInfo() {
　　　　　System.out.println("Je suis un chien");
　　}
}
class Main {
　　public static void main(String[] args) {
　　　　Dog d1　= new Dog();
　　　　Animal a1　= d1;　　　　//　Conversion vers le haut
　　　　if (a1　instanceof Dog) {
　　　　　　　Dog d2　= (Dog)a1;　　　　//　Conversion vers le bas
　　　　　　　d2.displayInfo();
　　　　}
　　}
}

Output:

Je suis un chien

Dans l'exemple précédent, nous utilisons l'opérateur instanceof pour vérifier a1L'objet est-il une instance de la classe Dog. Seulement lorsque l'expression a1 Le type de conversion vers le bas est effectué uniquement lorsque instanceof Dog est true.

Interface and instanceof

The instanceof operator is also used to check if the object of a class is also an instance of the interface implemented by the class.

Example7instanceof in the interface

interface Animal {
}
class Dog implements Animal {
}
class Main {
　　　public static void main(String[] args) {
　　　　　　Dog d1　= new Dog();
　　　　　　System.out.println("d1Is the object an instance of Animal?  "+(d1　instanceof Animal));
　　　}
}

Output:

d1Is the object an instance of Animal?  true

In the above example, we created a class that implements the Animal interface with Dog.

Then, create an object of the Dog class d1We have used the instanceof operator to check d1Is the object also an instance of the Animal interface?.