Relations entre les classes. Héritage, composition et agrégation

Bonjour! Aujourd'hui, nous examinerons de plus près un autre principe de la programmation orientée objet (POO) : l'héritage. Parallèlement, nous étudierons d'autres types de relations entre classes - composition et agrégation. Ce sujet ne sera pas difficile : vous avez déjà rencontré à plusieurs reprises l'héritage et ses exemples dans les cours précédents. Aujourd'hui l'essentiel sera de consolider vos connaissances, de regarder de plus près le mécanisme de l'héritage et de revoir les exemples :) Alors c'est parti !

L'héritage en Java et ses avantages

Comme vous vous en souvenez probablement, l'héritage est un mécanisme qui vous permet de décrire une nouvelle classe basée sur une classe (parente) existante. Dans ce cas, les propriétés et fonctionnalités de la classe parent sont empruntées par la nouvelle classe. Rappelons l'exemple d'héritage des cours précédents :

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 void gas() {
       //...gas
   }

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


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);
   }
}

Il existe un certain programme dans le cadre duquel nous travaillons avec différents types de voitures. Même si vous n'êtes pas un passionné de voitures, vous savez probablement qu'il existe un grand nombre de types de ces mêmes voitures dans le monde :) Par conséquent, nous séparons les propriétés générales des voitures en une classe mère commune - Car. Qu’ont en commun toutes les voitures, quel que soit leur type ? Toute voiture a une année de fabrication, un nom de modèle et une vitesse maximale. Nous mettons ces propriétés dans les champs model, maxSpeed, yearOfManufacture. Quant au comportement, n'importe quelle voiture peut accélérer et freiner :) Nous définissons ce comportement dans les méthodes gas()et brake(). Quels avantages cela nous apporte-t-il ? Tout d’abord, réduire la quantité de code. Bien sûr, on peut se passer de la classe parent. Mais puisque chaque voiture doit être capable d'accélérer et de freiner, nous devrons créer des méthodes gas()dans brake()la classe Truck, dans la classe Sedan, dans la classe F1Car, dans la classe Sportcaret dans toutes les autres classes de voitures. Imaginez combien de code supplémentaire nous écrirons dans ce cas. N’oubliez pas les champs model, maxSpeed ​​​​et yearOfManufacture : si on abandonne la classe parent, nous les créerons dans chacune des classes machine ! Lorsque nous aurons quelques dizaines de classes de machines, la quantité de code répétitif deviendra vraiment importante. Déplacer les champs et méthodes communs (également appelés « état » et « comportement ») dans la classe parent nous permettra de gagner beaucoup de temps et d'espace. Si un certain type possède des propriétés ou des méthodes qui lui sont propres et absentes des autres types de machines, cela n’a pas d’importance. Ils peuvent toujours être créés dans une classe descendante, séparément de toutes les autres.

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();
   }
}

Prenons le cas des voitures de course de Formule 1. Contrairement à leurs « parents », ils ont un comportement unique : ils font de temps en temps un arrêt au stand. Cela ne nous dérange pas. Nous avons déjà décrit le comportement général de la classe parent Car, et nous pouvons ajouter un comportement spécifique des classes enfants à l'intérieur des classes. Cela s'applique également aux champs : si une classe enfant a des propriétés uniques, nous pouvons déclarer sereinement ces champs à l'intérieur et ne pas nous inquiéter :) La possibilité de réutiliser le code est le principal avantage de l'héritage. Il est très important pour un programmeur de ne pas écrire de quantités inutiles de code. Vous rencontrerez cela plus d’une fois dans votre travail. N'oubliez pas une autre chose très importante : il n'y a pas d'héritage multiple en Java. Chaque classe hérite d'une seule classe. Nous parlerons des raisons de cela plus en détail dans les prochaines conférences, mais pour l’instant, rappelez-vous. Soit dit en passant, cela distingue Java de certains autres langages POO. Par exemple, C++ a un héritage multiple. Avec l'héritage, tout est plus ou moins clair - passons à autre chose.

Composition et agrégation

Les classes et les objets peuvent être liés les uns aux autres. L'héritage décrit la relation « est » (ou en anglais « IS A »). Le Lion est un animal. Cette relation peut être facilement exprimée en utilisant l'héritage, où Animalla classe sera le parent et Lionla classe sera l'enfant. Cependant, toutes les relations dans le monde ne sont pas décrites de cette manière. Par exemple, un clavier est certainement connecté à un ordinateur d’une manière ou d’une autre, mais ce n’est pas un ordinateur . Les mains sont en quelque sorte liées à la personne, mais elles ne sont pas la personne. Dans ces cas, elle repose sur un autre type de relation : non pas « est », mais « fait partie » (« HAS A »). La main n’est pas une personne, mais elle fait partie d’une personne. Le clavier n’est pas un ordinateur, mais il en fait partie. HAS Une relation peut être décrite dans le Code à l'aide de mécanismes de composition et d'agrégation . La différence entre eux réside dans la « rigueur » de ces connexions. Donnons un exemple simple : nous avons la nôtre Car- une voiture. Chaque voiture a un moteur. De plus, chaque voiture a des passagers à l’intérieur. Quelle est la différence fondamentale entre les champs Engine engineet Passenger [] passengers? Si une voiture a un passager à l'intérieur А, cela ne signifie pas qu'il ne peut pas y avoir de passagers à Bbord C. Une voiture peut accueillir plusieurs passagers. De plus, si tous les passagers sont retirés de la voiture, celle-ci continuera à fonctionner silencieusement. La relation entre classe Caret masse de passagers Passenger [] passengersest moins stricte. C'est ce qu'on appelle l'agrégation . Il existe un bon article sur ce sujet : Relations entre classes (objets) . Cela fournit un autre bon exemple d’agrégation. Disons que nous avons une classe Studentdésignant un étudiant et une classe StudentsGroup(un groupe d'étudiants). Un étudiant peut être membre d'un club de physique, d'un fan club étudiant de Star Wars ou d'une équipe KVN. La composition est un type de communication plus strict. Lors de l’utilisation de la composition, non seulement un objet fait partie d’un objet, mais il ne peut pas appartenir à un autre objet du même type. L’exemple le plus simple est celui d’un moteur de voiture. Un moteur fait partie d’une voiture, mais ne peut pas faire partie d’une autre voiture. Comme vous pouvez le constater, leur connexion est beaucoup plus stricte que celle de Caret Passengers.