Instanceof et héritage en Java

Salut! Dans les leçons précédentes, nous nous sommes déjà brièvement familiarisés avec le concept d'héritage. Aujourd'hui, nous aborderons à nouveau ce sujet, mais encore une fois pas trop profondément. Nous aurons encore une leçon plus détaillée à ce sujet à l'avenir. Aujourd'hui, nous allons simplement jeter un coup d'œil à quelques exemples pratiques et nous familiariser avec un opérateur intéressant en Java.

Héritage

Alors, qu'est-ce que l'héritage ? L'héritage est un mécanisme de programmation (y compris en Java) qui permet de déclarer une nouvelle classe à partir d'une classe existante. La classe dérivée accède alors aux champs et aux méthodes de la classe parent. Pourquoi aurions-nous besoin de cela ? Eh bien, imaginez que vous ayez besoin de créer plusieurs classes de voitures dans un programme : Camion, RaceCar, Sedan, Pickup, etc. Avant même d'écrire le moindre code, vous savez avec certitude que toutes ces classes ont beaucoup en commun : toutes les voitures ont un modèle nom, année de fabrication, cylindrée, vitesse maximale, etc. (sans parler du fait qu'ils ont tous des roues et d'autres pièces en commun). Dans cette situation, vous pouvez :

• Créez ces champs dans chaque classe (en les ajoutant à chaque nouvelle classe de voiture au fur et à mesure que vous la créez)
• Amenez les champs communs à toutes les voitures dans une Carclasse parent, puis utilisez le mot-clé extend pour dériver toutes les classes pour des types spécifiques de voitures à partir de la Carclasse.

Naturellement, la deuxième option est beaucoup plus pratique :

public class Car {

   private String model;
   private int maxSpeed;
   private int yearOfManufacture;

   public Car(String model, int maxSpeed, int yearOfManufacture) {
       this.model = model;
       this.maxSpeed = maxSpeed;
       this.yearOfManufacture = yearOfManufacture;
   }
}

public class Truck extends Car {

   public Truck(String model, int maxSpeed, int yearOfManufacture) {
       super(model, maxSpeed, yearOfManufacture);
   }
}

public class Sedan extends Car {
   public Sedan(String model, int maxSpeed, int yearOfManufacture) {
       super(model, maxSpeed, yearOfManufacture);
   }
}

Au minimum, nous évitons la duplication inutile de code (et nous devrions toujours nous y efforcer lors de l'écriture de programmes). De plus, nous avons une structure de classe simple et compréhensible, avec tous les champs communs à toutes les voitures regroupés en une seule classe. Si les camions ont des champs spéciaux que les autres voitures n'ont pas, ils peuvent être déclarés dans la Truckclasse. Il en va de même pour les méthodes. Toutes les voitures ont un certain comportement commun qui peut être décrit avec des méthodes, par exemple démarrer la voiture, accélérer/freiner, etc. Ces méthodes communes peuvent être consolidées dans la Carclasse parente, et chaque type spécifique de voiture peut définir ses actions uniques dans leurs classes dérivées. .

public class Car {

   public void gas() {
       // Accelerate
   }

   public void brake() {
       // Brake
   }
}


public class F1Car extends Car {

   public void pitStop() {
      
       // Only race cars make pit stops
   }

   public static void main(String[] args) {
      
       F1Car formula1Car = new F1Car();
       formula1Car.gas();
       formula1Car.pitStop();
       formula1Car.brake();
   }
}

Nous avons ajouté les méthodes communes à toutes les voitures à la Carclasse. Mais, regardez la F1Carclasse, qui représente les voitures de course "Formule 1". Les arrêts aux stands (arrêts pour l'entretien urgent de la voiture) ne sont effectués que dans les courses, nous avons donc ajouté cette fonctionnalité spécifique à la classe dérivée correspondante.

opérateur instanceof

En Java, il existe un opérateur spécial, instanceof , pour vérifier si un objet a été créé sur la base d'une classe particulière. Il renvoie vrai ou faux selon le résultat de la vérification. Voyons comment cela fonctionne en utilisant les classes de notre exemple de voiture :

public class Truck extends Car {

   public static void main(String[] args) {

       Truck truck = new Truck();
       System.out.println(truck instanceof Car);
   }
}

Sortie : true L' instanceofopérateur renvoie true , puisque nous avons un Truckobjet et que tous les camions sont des voitures. La Truckclasse est dérivée de la Carclasse. Tous les camions sont créés sur la base du parent commun, la Carclasse. Regardez attentivement comment l' instanceofopérateur est utilisé. Vous l'écrivez sans point, puisqu'il s'agit d'un opérateur, pas d'une méthode ("object instanceof Class"). Essayons une autre manière :

public static void main(String[] args) {

   Car car = new Car();
   System.out.println(car instanceof Truck);
}

Sortie : false La Carclasse (et les objets voiture) ne dérive pas de la Truckclasse. Tous les camions sont des voitures, mais toutes les voitures ne sont pas des camions. Carles objets ne sont pas basés sur la Truckclasse. Un autre exemple :

public static void main(String[] args) {

   Car car = new Car();
   Truck truck = new Truck();
   System.out.println(car instanceof Object && truck instanceof Object);
}

Sortie : True Ici, la logique est également simple : toutes les classes en Java, y compris les classes que vous créez, descendent de la Objectclasse (même si vous n'écrivez pas "extends Object" - c'est déjà implicite). Comment et quand cela serait-il utile ? L' instanceofopérateur est le plus souvent utilisé lors du remplacement de la equals()méthode. Par exemple, voici comment la equalsméthode est implémentée dans la Stringclasse :

public boolean equals(Object anObject) {
   if (this == anObject) {
       return true;
   }
   if (anObject instanceof String) {
       String anotherString = (String) anObject;
       int n = value.length;
       if (n == anotherString.value.length) {
           char v1[] = value;
           char v2[] = anotherString.value;
           int i = 0;
           while (n-- != 0) {
               if (v1[i] != v2[i])
                       return false;
               i++;
           }
           return true;
       }
   }
   return false;
}

Avant de comparer a Stringà l'objet passé, la méthode teste pour voir si l'objet est même une chaîne ? Ce n'est qu'alors qu'il commence à comparer les propriétés des deux objets. Si ce test n'existait pas, tout objet avec des champs de valeur et de longueur pourrait être passé à la méthode et comparé à une chaîne, ce qui serait faux, bien sûr.