Ins­tan­ceof en Java : comment cet opérateur fonc­tionne ?

L’opérateur Java ins­tan­ceof vérifie la cor­res­pon­dance entre un objet et une classe. L’opérateur fournit cette in­for­ma­tion sous la forme d’une ex­pres­sion booléenne, c’est-à-dire « vrai » ou « faux ». La vé­ri­fi­ca­tion permet d’éviter les messages d’erreur.

Qu’est-ce qu’ins­tan­ceof en Java ?

Toutes les variables en Java ne se dis­tin­guent pas de manière immédiate par leur spé­ci­fi­cité. Dès lors notamment qu’un grand projet est créé dans le langage de pro­gram­ma­tion en réu­nis­sant de nom­breuses variables, les données d’entrée peuvent, par exemple, déboucher sur l’ap­pa­ri­tion d’une variable à la fin comme étant celle de plusieurs objets. Java fournit l’opérateur ins­tan­ceof à cet effet. Il garantit que l’instance d’une variable de référence cor­res­pond ef­fec­ti­ve­ment à 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 cor­res­pon­dance, la sortie se traduit par « false » (faux).

Avant de convertir un objet inconnu, il convient im­pé­ra­ti­ve­ment d’exécuter ins­tan­ceof en Java pour s’assurer que l’objet ap­par­tient à la classe supposée. En l’absence de ce contrôle de sécurité, une Class­Cas­tEx­cep­tion 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 par­ti­cu­lier dans un code allongé, il est pré­fé­rable d’anticiper les problèmes éventuels.

Mode de fonc­tion­ne­ment et syntaxe

Lorsque vous exécutez ins­tan­ceof 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é­cla­ra­tion sur la nature de l’objet ou de la classe, mais précise sim­ple­ment si une cor­res­pon­dance existe ou non. La syntaxe est par con­sé­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 ins­tan­ceof en Java

On peut com­prendre la nature et le fonc­tion­ne­ment d’ins­tan­ceof en Java le plus sim­ple­ment à l’aide d’un court exemple. Pour ce faire, nous com­men­ç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 {
}

Main­te­nant, nous pouvons utiliser ins­tan­ceof en Java pour vérifier si une instance de « Chat » ap­par­tient à 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 res­sem­bler à ceci :

true

Plusieurs niveaux et la classe Object

Ce principe fonc­tionne également avec la classe Main et d’autres sous-classes. Pour illustrer cela, nous partons d’un autre exemple mul­ti­ni­veaux et étendons l’opérateur ins­tan­ceof en Java avec l’ins­truc­tion if-else. Les textes figurant derrière les deux barres obliques sont des com­men­taires JAVA, qui ex­pli­quent seulement les étapes in­di­vi­duelles, 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é­rar­chie, « Chat1 » est également une instance d’Object. L’opérateur Java ins­tan­ceof sortira donc toujours « true » lorsqu’il est appliqué à la classe Object. La sortie cor­res­pon­dante 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 ins­tan­ceof en Java renvoie au­to­ma­ti­que­ment « 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 ap­pro­prié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é­rar­chie ap­par­tien­nent également aux classes parentes, ce principe ne fonc­tionne pas en sens inverse. Nous pouvons com­prendre 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 cor­res­pond à :

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 ex­pli­quons ceci également à l’aide d’un exemple et nous créons une nouvelle classe appelée « Chien », qui ap­par­tient à 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