# 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 :

```java
(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 ».

```java
public class Animal {
}
```

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

```java
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 :

```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 :

```java
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.

```java
// 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 :

```java
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 :

```java
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 :

```java
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 :

```java
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 à :

```java
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 ».

```java
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
java.lang.Error: Unresolved compilation problem:
Incompatible conditional operand types Chat and Chien
```

Conseil Dans notre Digital Guide, vous trouverez davantage de tutoriels tout aussi passionnants et des articles informatifs sur Java. Par exemple, nous comparons [Java et JavaScript](https://www.ionos.com/fr-be/digitalguide/sites-internet/developpement-web/java-vs-javascript/) ainsi que [Java et Python](https://www.ionos.com/fr-be/digitalguide/sites-internet/developpement-web/python-vs-java/). Si vous souhaitez en savoir plus sur les [opérateurs Java Bitwise](https://www.ionos.com/fr-be/digitalguide/sites-internet/developpement-web/les-operateurs-java-bitwise/), nous vous proposons aussi le guide approprié.


This is a markdown version of: [https://www.ionos.com/fr-be/digitalguide/sites-internet/developpement-web/loperateur-instanceof-en-java/](https://www.ionos.com/fr-be/digitalguide/sites-internet/developpement-web/loperateur-instanceof-en-java/) for AI/LLM consumption.