bases de l'instance et de l'héritage

Bonjour! Dans les cours précédents, nous avons déjà brièvement abordé à plusieurs reprises la notion d’héritage. Aujourd'hui, nous aborderons également ce sujet, mais pas trop profondément. Il y aura une conférence détaillée à ce sujet plus tard, mais aujourd'hui, nous allons simplement examiner des exemples pratiques et nous familiariser avec un opérateur intéressant en Java.

Héritage Java

Alors, qu’est-ce que l’héritage exactement ? L'héritage est un mécanisme de programmation, y compris Java, qui permet de décrire une nouvelle classe basée sur une classe existante. La classe descendante accède alors aux champs et méthodes de la classe parent. Pourquoi cela pourrait-il être nécessaire ? Eh bien, par exemple, imaginez que vous deviez créer plusieurs classes de voitures dans le programme : Camion, Course, Berline, Pickup, etc. Même sans commencer à écrire du code, vous savez avec certitude que ces classes ont beaucoup en commun : toutes les voitures ont un nom de modèle, une année de fabrication, une cylindrée, une vitesse maximale, etc. (sans parler du fait qu'ils ont tous des roues et autres pièces). Dans une telle situation, vous pouvez :

• Créez ces champs dans chaque classe et ajoutez-les aux nouvelles classes de voitures lors de leur création
• Déplacez les champs communs à toutes les machines dans la classe parent Car, et toutes les classes de types spécifiques de machines héritent de Carl'utilisation du mot extends .

La deuxième option, bien sûr, 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 avons évité la duplication inutile de code, et c'est quelque chose que nous devrions toujours rechercher lors de l'écriture de programmes. De plus, nous avons une structure de classe simple et compréhensible : les champs communs à toutes les machines sont placés dans une seule classe. Si, par exemple, les camions ont des champs spécifiques que les autres voitures n'ont pas, ils peuvent être déclarés dans le Truck. Il en va de même pour les méthodes. Toutes les voitures ont un comportement commun qui peut être décrit : démarrer la voiture, gaz/frein, etc. Ces méthodes générales peuvent être placées dans une classe générale Caret le comportement spécifique de chaque type spécifique peut être décrit dans des classes descendantes.

public class Car {

   public void gas() {
       //...gas
   }

   public void brake() {
       //...brake
   }
}


public class F1Car extends Car {

   public void pitStop() {

       //...only racing cars make pit stops
   }

   public static void main(String[] args) {

       F1Car formula1Car = new F1Car();
       formula1Car.gas();
       formula1Car.pitStop();
       formula1Car.brake();
   }
}

Nous avons déplacé les méthodes communes à toutes les voitures dans la classe Car. Mais dans la classe suivante F1Car, qui décrit les voitures de course de Formule 1 - les arrêts aux stands (arrêts pour entretien urgent de la voiture), qui se font uniquement en course et se distinguent par un comportement spécifique.

Opérateur d'instance Java

Pour vérifier si un objet est créé sur la base d'une classe, il existe un opérateur spécial en Java - instanceof. Il renvoie la valeur truesi le test était vrai ou falsesi le résultat était faux. Voyons comment cela fonctionne en utilisant nos classes de voitures comme exemple :

public class Truck extends Car {

   public static void main(String[] args) {

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

Résultat : true Test utilisant l'opérateur instanceofrenvoyé true, puisque nous avons un objet de la classe Trucket que tous les camions sont des voitures. La classe Truckest un descendant de la classe Car, par conséquent, tous les camions sont créés sur la base d'un parent commun - une voiture. Faites attention à l'opérateur instanceof: il est écrit sans point, puisqu'il s'agit d'un opérateur, pas d'une méthode (« objet instanceof Class »). Essayons différemment :

public static void main(String[] args) {

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

Résultat : false La classe Caret, par conséquent, son objet ne dérivent pas de la classe Truck. Tous les camions sont des voitures, mais toutes les voitures ne sont pas des camions. Les objets Carne sont pas créés en fonction de la classe Truck. Encore un exemple :

public static void main(String[] args) {

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

Résultat : True La logique ici est également simple : toutes les classes en Java, y compris celles que vous avez créées, proviennent d'une classe Object(même si vous n'y écrivez pas d'objet extends - ce mécanisme y est implicite). Pourquoi cela pourrait-il être utile et dans quelles circonstances ? L'utilisation la plus courante de l'opérateur instanceofest celle d'un remplacement de méthode equals(). Par exemple, voici comment la méthode est implémentée equalsdans la classe String:

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 la chaîne avec l'objet passé, la méthode vérifie : l'objet passé est-il réellement une chaîne ? Et c’est seulement alors qu’il commence à comparer les propriétés de deux objets. Sans cette vérification, vous pourriez transmettre n'importe quel objet comportant des champs de valeur et de longueur dans la méthode et le comparer avec une chaîne, ce qui, bien sûr, serait faux.