Comment vérifier si un objet est d'un type spécifique en Java

Introduction

Dans ce laboratoire (lab), vous apprendrez à vérifier si un objet est d'un type spécifique en Java en utilisant l'opérateur instanceof. Vous commencerez par comprendre l'utilisation de base de instanceof avec différentes classes, y compris l'héritage.

Vous testerez ensuite l'opérateur instanceof avec différents types de classes et explorerez son comportement avec les sous-classes et les superclasses. Enfin, vous apprendrez à gérer les objets nuls lors de l'utilisation de instanceof pour éviter les erreurs potentielles.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL java(("Java")) -.-> java/BasicSyntaxGroup(["Basic Syntax"]) java(("Java")) -.-> java/ObjectOrientedandAdvancedConceptsGroup(["Object-Oriented and Advanced Concepts"]) java/BasicSyntaxGroup -.-> java/if_else("If...Else") java/ObjectOrientedandAdvancedConceptsGroup -.-> java/classes_objects("Classes/Objects") java/ObjectOrientedandAdvancedConceptsGroup -.-> java/inheritance("Inheritance") subgraph Lab Skills java/if_else -.-> lab-560012{{"Comment vérifier si un objet est d'un type spécifique en Java"}} java/classes_objects -.-> lab-560012{{"Comment vérifier si un objet est d'un type spécifique en Java"}} java/inheritance -.-> lab-560012{{"Comment vérifier si un objet est d'un type spécifique en Java"}} end

Utiliser l'opérateur instanceof

Dans cette étape, vous allez apprendre à propos de l'opérateur instanceof en Java. L'opérateur instanceof est utilisé pour tester si un objet est une instance d'une classe particulière ou implémente une interface particulière. C'est un outil utile pour vérifier le type d'un objet à l'exécution.

Créons un simple programme Java pour démontrer le fonctionnement de l'opérateur instanceof.

Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE s'il n'est pas déjà ouvert.

Remplacez tout le contenu du fichier par le code suivant :

class Animal {
    public void makeSound() {
        System.out.println("Generic animal sound");
    }
}

class Dog extends Animal {
    public void makeSound() {
        System.out.println("Woof!");
    }
}

class Cat extends Animal {
    public void makeSound() {
        System.out.println("Meow!");
    }
}

public class HelloJava {
    public static void main(String[] args) {
        Animal myAnimal = new Dog();

        if (myAnimal instanceof Dog) {
            System.out.println("myAnimal is an instance of Dog");
        }

        if (myAnimal instanceof Cat) {
            System.out.println("myAnimal is an instance of Cat");
        }

        if (myAnimal instanceof Animal) {
            System.out.println("myAnimal is an instance of Animal");
        }
    }
}

Dans ce code :

Nous définissons une classe de base Animal et deux sous-classes Dog et Cat.
Dans la méthode main, nous créons une variable Animal nommée myAnimal et nous lui assignons un objet Dog.
Nous utilisons ensuite l'opérateur instanceof pour vérifier si myAnimal est une instance de Dog, Cat et Animal.

Enregistrez le fichier (Ctrl+S ou Cmd+S).
Compilez le programme en utilisant la commande javac dans le terminal :
```
javac HelloJava.java
```
Exécutez le programme compilé en utilisant la commande java :
```
java HelloJava
```
Vous devriez voir un résultat indiquant quelles vérifications instanceof ont retourné true.
```
myAnimal is an instance of Dog
myAnimal is an instance of Animal
```
Comme vous pouvez le voir, myAnimal est une instance de Dog (parce que nous avons créé un objet Dog) et également une instance de Animal (parce que Dog est une sous-classe de Animal). Il n'est pas une instance de Cat.

Tester avec différentes classes

Dans l'étape précédente, vous avez vu comment instanceof fonctionne avec une sous-classe et sa superclasse. Maintenant, explorons son comportement lorsqu'il est utilisé pour tester des classes différentes et non liées.

Nous allons modifier le fichier HelloJava.java existant pour inclure une autre classe et tester l'opérateur instanceof avec des objets de différents types.

Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE.
Ajoutez une nouvelle classe appelée Car au fichier. Vous pouvez ajouter cette définition de classe avant ou après les classes Animal, Dog et Cat, mais en dehors de la classe HelloJava.
```
class Car {
    public void drive() {
        System.out.println("Driving a car");
    }
}
```

Maintenant, modifions la méthode main dans la classe HelloJava pour créer un objet Car et tester l'opérateur instanceof. Mettez à jour la méthode main pour qu'elle ressemble à ceci :

public class HelloJava {
    public static void main(String[] args) {
        Animal myAnimal = new Dog();
        Car myCar = new Car();

        if (myAnimal instanceof Dog) {
            System.out.println("myAnimal is an instance of Dog");
        }

        if (myAnimal instanceof Cat) {
            System.out.println("myAnimal is an instance of Cat");
        }

        if (myAnimal instanceof Animal) {
            System.out.println("myAnimal is an instance of Animal");
        }

        System.out.println("--- Testing Car object ---");

        if (myCar instanceof Car) {
            System.out.println("myCar is an instance of Car");
        }

        if (myCar instanceof Animal) {
            System.out.println("myCar is an instance of Animal");
        }
    }
}

Nous avons ajouté un nouvel objet Car nommé myCar et inclus des vérifications instanceof pour lui par rapport à Car et Animal.

Enregistrez le fichier (Ctrl+S ou Cmd+S).
Compilez le programme modifié :
```
javac HelloJava.java
```
Exécutez le programme :
```
java HelloJava
```
Observez la sortie. Vous devriez voir les résultats de l'étape précédente, suivis des résultats des nouvelles vérifications pour l'objet Car.
```
myAnimal is an instance of Dog
myAnimal is an instance of Animal
--- Testing Car object ---
myCar is an instance of Car
```
Cette sortie confirme que myCar est une instance de Car, mais ce n'est pas une instance de Animal car Car n'hérite pas de Animal. L'opérateur instanceof identifie correctement la relation de type (ou son absence) entre les objets et les classes.

Gérer les objets null

Dans cette étape finale, nous allons explorer le comportement de l'opérateur instanceof lorsqu'il est utilisé avec des objets null. Comprendre ceci est important pour éviter des erreurs inattendues dans vos programmes.

Une référence null en Java signifie qu'une variable ne fait référence à aucun objet. Lorsque vous utilisez l'opérateur instanceof avec une référence null, il renverra toujours false. C'est une fonctionnalité de sécurité intégrée à l'opérateur.

Modifions le fichier HelloJava.java une dernière fois pour inclure un objet null et tester l'opérateur instanceof.

Ouvrez le fichier HelloJava.java dans l'éditeur WebIDE.

Modifiez la méthode main dans la classe HelloJava pour inclure une référence Animal null et la tester. Mettez à jour la méthode main pour qu'elle ressemble à ceci :

class Animal {
    public void makeSound() {
        System.out.println("Generic animal sound");
    }
}

class Dog extends Animal {
    public void makeSound() {
        System.out.println("Woof!");
    }
}

class Cat extends Animal {
    public void makeSound() {
        System.out.println("Meow!");
    }
}

class Car {
    public void drive() {
        System.out.println("Driving a car");
    }
}

public class HelloJava {
    public static void main(String[] args) {
        Animal myAnimal = new Dog();
        Car myCar = new Car();
        Animal nullAnimal = null; // Déclare une référence Animal null

        if (myAnimal instanceof Dog) {
            System.out.println("myAnimal is an instance of Dog");
        }

        if (myAnimal instanceof Cat) {
            System.out.println("myAnimal is an instance of Cat");
        }

        if (myAnimal instanceof Animal) {
            System.out.println("myAnimal is an instance of Animal");
        }

        System.out.println("--- Testing Car object ---");

        if (myCar instanceof Car) {
            System.out.println("myCar is an instance of Car");
        }

        if (myCar instanceof Animal) {
            System.out.println("myCar is an instance of Animal");
        }

        System.out.println("--- Testing null object ---");

        if (nullAnimal instanceof Animal) {
            System.out.println("nullAnimal is an instance of Animal");
        }

        if (nullAnimal instanceof Dog) {
            System.out.println("nullAnimal is an instance of Dog");
        }
    }
}

Nous avons ajouté une nouvelle variable Animal nommée nullAnimal et l'avons initialisée à null. Nous effectuons ensuite des vérifications instanceof avec elle.

Enregistrez le fichier (Ctrl+S ou Cmd+S).
Compilez le programme :
```
javac HelloJava.java
```
Exécutez le programme :
```
java HelloJava
```
Observez la sortie. Vous devriez voir les résultats des étapes précédentes, suivis des résultats des vérifications pour nullAnimal.
```
myAnimal is an instance of Dog
myAnimal is an instance of Animal
--- Testing Car object ---
myCar is an instance of Car
--- Testing null object ---
```
Notez que les lignes à l'intérieur des blocs if pour nullAnimal ne sont pas affichées. C'est parce que nullAnimal instanceof Animal et nullAnimal instanceof Dog évaluent toutes les deux à false. Cela démontre que l'opérateur instanceof gère correctement les références null en renvoyant false.

Comprendre le fonctionnement de instanceof avec null est crucial pour écrire un code Java robuste qui évite les erreurs de type NullPointerException.

Résumé

Dans ce laboratoire, vous avez appris à vérifier si un objet est d'un type spécifique en Java en utilisant l'opérateur instanceof. Vous avez pratiqué l'utilisation de instanceof avec différentes classes, y compris une classe de base et ses sous-classes, pour déterminer le type d'un objet à l'exécution. Vous avez également exploré le comportement de instanceof lors de la vérification par rapport à la classe réelle de l'objet, à sa superclasse et à des classes non liées.