Instanceof en Java : comment cet opérateur fonctionne ?

L’opérateur Java instanceof vérifie la correspondance entre un objet et une classe. L’opérateur fournit cette information sous la forme d’une expression booléenne, c’est-à-dire « vrai » ou « faux ». La vérification permet d’éviter les messages d’erreur.

Qu’est-ce qu’instanceof en Java ?

Toutes les variables en Java ne se distinguent pas de manière immédiate par leur spécificité. Dès lors notamment qu’un grand projet est créé dans le langage de programmation en réunissant de nombreuses variables, les données d’entrée peuvent, par exemple, déboucher sur l’apparition d’une variable à la fin comme étant celle de plusieurs objets. Java fournit l’opérateur instanceof à cet effet. Il garantit que l’instance d’une variable de référence correspond effectivement à une classe, une sous-classe ou une interface. Si c’est le cas, l’opérateur retourne la valeur booléenne « true » (vrai). S’il n’y a pas de correspondance, la sortie se traduit par « false » (faux).

Avant de convertir un objet inconnu, il convient impérativement d’exécuter instanceof en Java pour s’assurer que l’objet appartient à la classe supposée. En l’absence de ce contrôle de sécurité, une ClassCastException peut être émise. Cela se produit lorsqu’un objet doit être converti en une autre classe. Le message d’erreur pouvant être source de confusion, en particulier dans un code allongé, il est préférable d’anticiper les problèmes éventuels.

Mode de fonctionnement et syntaxe

Lorsque vous exécutez instanceof en Java, l’opérateur compare une variable de référence à une classe précise que vous spécifiez également. Il n’opère aucune autre déclaration sur la nature de l’objet ou de la classe, mais précise simplement si une correspondance existe ou non. La syntaxe est par conséquent très simple. Elle se présente comme suit :

(object) instanceof (classe)

Si (objet) est une instance de (classe), « true » est renvoyé. Si ce n’est pas le cas, « false » apparaît.

Exemple simple d’un opérateur instanceof en Java

On peut comprendre la nature et le fonctionnement d’instanceof en Java le plus simplement à l’aide d’un court exemple. Pour ce faire, nous commençons par créer une classe appelée « Animal ».

public class Animal {
}

Au cours de l’étape suivante, nous étendons cette classe (extend en anglais) avec une sous-classe appelée « Chat ».

public class Chat extends Animal {
}

Maintenant, nous pouvons utiliser instanceof en Java pour vérifier si une instance de « Chat » appartient à la classe « Animal ». Nous utilisons les lignes suivantes à cet effet, et sortons system.out.println avec la commande Java :

public class Animal {}
public class Chat extends Animal {
public static void main(String args []{
Chat Chat = new Chat();
System.out.println(Chat instanceof Animal);
}
}

Le résultat doit ressembler à ceci :

true

Plusieurs niveaux et la classe Object

Ce principe fonctionne également avec la classe Main et d’autres sous-classes. Pour illustrer cela, nous partons d’un autre exemple multiniveaux et étendons l’opérateur instanceof en Java avec l’instruction if-else. Les textes figurant derrière les deux barres obliques sont des commentaires JAVA, qui expliquent seulement les étapes individuelles, mais ne jouent aucun rôle dans la sortie.

// Classe 1
// Classe mère
public class Animal {
}
// Classe 2
// Sous-classe
class Chat extends Animal {
}
// Classe 3
// Classe Main
class Main {
public static void main(String[] args)
Chat Chat1 = new Chat();
if (Chat1 instanceof Chat)
	System.out.println ("Chat1 est une instance de Chat");
else
	System.out.println ("Chat1 N’EST PAS une instance de Chat");
if (Chat1 instanceof Animal)
	System.out.println ("Chat1 est une instance d’Animal");
else
	System.out.println ("Chat1 N’EST PAS une instance d’Animal");
if (Chat1 instanceof Object)
	System.out.println ("Chat1 est une instance d’Object");
else
	System.out.println ("Chat1 N’EST PAS une instance d’Object");
	}
}

Puisque « Chat1 » est une instance de la classe « Chat » et de la classe mère « Animal » dans notre exemple, les deux requêtes reçoivent la réponse « true ». Comme Object ou la classe « java.lang.Object » est au sommet de la hiérarchie, « Chat1 » est également une instance d’Object. L’opérateur Java instanceof sortira donc toujours « true » lorsqu’il est appliqué à la classe Object. La sortie correspondante se présente donc comme suit :

Chat1 est une instance de Chat
Chat1 est une instance d’Animal
Chat1 est une instance d’Object

Sortie en cas de valeur nulle

Si une variable a la valeur 0, et ne contient donc aucun objet, l’opérateur instanceof en Java renvoie automatiquement « false ». Vous pouvez vérifier cela en vous appuyant sur l’exemple suivant :

class Chat {
}
class Main {
public static void main(String[] args)
{
Chat Chat2 = null;
if (Chat2 instanceof Chat)
	System.out.println ("Chat2 est une instance de Chat");
else
	System.out.println ("Chat2 N’EST PAS une instance de Chat");
	}
}

La sortie appropriée dans ce cas est :

Chat1 N’EST PAS une instance de Chat

Les classes mères ne sont pas une instance d’une classe dérivée

Alors que les objets des sous-classes de la hiérarchie appartiennent également aux classes parentes, ce principe ne fonctionne pas en sens inverse. Nous pouvons comprendre ceci à travers notre exemple ci-dessous :

class Animal {
}
class Chat extends Animal {
}
class Main {
public static void main(String[] args)
{
Animal Bello = new Animal ();
if (Bello instanceof Chat)
	System.out.println ("Bello est une instance de Chat");
else
	System.out.println ("Bello N’EST PAS une instance de Chat");
	}
}

Dans ce cas, la sortie correspond à :

Bello N’EST PAS une instance de Chat

Message d’erreur en cas de relation manquante

Un message d’erreur est émis en l’absence de relation entre l’objet et la classe avec laquelle il doit être comparé. Nous vous expliquons ceci également à l’aide d’un exemple et nous créons une nouvelle classe appelée « Chien », qui appartient à la classe mère « Animal », mais qui n’est pas associée à « Chat ».

class Chien implements Animal {
}
class Main {
public static void main(String[] args)
{
Chat Chat3 = new Chat ();
System.out.println (Chat3 instanceof Chien);
	}
}

Dans ce cas, nous obtenons un message d’erreur qui nous avertit sur l’absence de relation entre les classes « Chat » et « Chien ». Le message se présente comme suit :

java.lang.Error: Unresolved compilation problem:
Incompatible conditional operand types Chat and Chien