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

Salut! Aujourd'hui, nous allons examiner de plus près un principe de la programmation orientée objet (POO) : l'héritage. Nous étudierons également d'autres types de relations entre classes : la composition et l'agrégation. Ce sujet ne sera pas difficile : vous avez déjà rencontré de nombreuses fois l'héritage et des exemples d'héritage dans les leçons précédentes. Aujourd'hui, l'essentiel sera de renforcer vos connaissances, d'approfondir le mécanisme de l'héritage, et encore une fois de parcourir quelques exemples. :) Eh bien, allons-y!

L'héritage en Java et ses avantages

Comme vous vous en souvenez sûrement, l'héritage est un mécanisme qui permet de décrire une nouvelle classe à partir d'une classe existante (classe mère). Ce faisant, la nouvelle classe emprunte les propriétés et les fonctionnalités de la classe parent. Rappelons un exemple d'héritage donné dans les leçons précédentes :

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

Nous avons un certain programme qui implique de travailler avec différents types de voitures. Même si vous n'êtes pas un passionné de voitures, vous savez probablement qu'il existe de nombreux types de voitures dans le monde. :) En conséquence, nous séparerons les propriétés communes des voitures dans une classe parente commune appelée Car. Alors qu'est-ce qui est commun à toutes les voitures, quel que soit leur type ? Chaque 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, maxSpeedet yearOfManufacture. Quant au comportement, n'importe quelle voiture peut accélérer et ralentir. :) Nous définissons ce comportement dans le gas()etbrake()méthodes. Quels avantages cela nous apporte-t-il ? Tout d'abord, cela réduit 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 ralentir, nous devrons créer des méthodes gas()et brake()dans les classes Truck, Sedan, F1Car, et SportsCaret dans toutes les autres classes de voitures. Imaginez la quantité de code supplémentaire que nous aurions à écrire. Et n'oubliez pas les champs model, maxSpeed, et yearOfManufacture: si nous nous débarrassons de la classe mère, nous devrons les créer dans chaque classe de voiture ! Lorsque nous avons quelques dizaines de classes de voitures, la quantité de code en double devient vraiment sérieuse. Déplacer des champs et des méthodes communs (également appelés "états" et "comportements") vers une classe parente nous permet d'économiser beaucoup de temps et d'espace. Si un type a des propriétés ou des méthodes uniques que d'autres types de voitures n'ont pas, ce n'est pas grave. Vous pouvez toujours les créer dans une classe descendante, séparée de tout le monde.

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

Prenons l'exemple des voitures de course de Formule 1. Contrairement à leurs "parents", ils ont un comportement unique : ils s'arrêtent de temps en temps. Cela ne nous dérange pas. Nous avons déjà décrit le comportement commun dans la Carclasse parent, et le comportement spécifique des classes descendantes peut être ajouté à ces classes. Il en va de même pour les champs : si une classe enfant a des propriétés uniques, nous déclarons calmement ces champs à l'intérieur de la classe enfant et cessons de nous inquiéter. :) La possibilité de réutiliser le code est le principal avantage de l'héritage. Pour les programmeurs, il est très important de ne pas écrire de code supplémentaire. Vous rencontrerez cela à plusieurs reprises dans votre travail. S'il vous plaît rappelez-vous quelque chose d'autre crucial: Java n'a pas d'héritage multiple. Chaque classe hérite d'une seule classe. Nous en reparlerons plus en détails dans les prochaines leçons. Pour l'instant, rappelez-vous-en. Soit dit en passant, cela rend Java différent de certains autres langages POO. Par exemple, C++ prend en charge l'héritage multiple. Tout est plus ou moins clair avec l'héritage. Allons-nous en.

Composition et agrégation

Les classes et les objets peuvent être liés entre eux. L'héritage décrit une relation "est-un". Un lion est un animal. Une telle relation est facilement exprimée en utilisant l'héritage, où Animalest la classe parent et Lionest l'enfant. Cependant, toutes les relations ne sont pas décrites de cette façon. Par exemple, un clavier est certainement lié à un ordinateur, mais ce n'est pas un ordinateur . Les mains sont en quelque sorte liées à une personne, mais elles ne sont pas une personne. Dans ces cas, nous avons un autre type de relation : non pas "est-un", mais "a-un". Une main n'est pas une personne, mais fait partie d'une personne. Un clavier n'est pas un ordinateur, mais fait partie d'un ordinateur. Une relation has-a peut être décrite dans le code en utilisant la composition et l'agrégation. La différence réside dans la « rigueur » de la relation. Donnons un exemple simple : nous avons une Carclasse. Chaque voiture a un moteur. De plus, chaque voiture a des passagers. Quelle est la différence fondamentale entre les champs Engine engineet Passenger[] passengers? Le fait que le passager Asoit assis dans une voiture ne signifie pas que les passagers Bet Cne sont pas dans la voiture. Une voiture peut correspondre à plusieurs passagers. De plus, si tous les passagers sortent d'une voiture, elle fonctionnera toujours sans problème. La relation entre la Carclasse et le Passenger[] passengerstableau est moins stricte. C'est ce qu'on appelle l'agrégation . Il fournit un autre bon exemple d'agrégation. Supposons que nous ayons une Studentclasse et unStudentGroupclasse. Un étudiant peut rejoindre plusieurs organisations étudiantes : un club de physique, un fan club de Star Wars et/ou un club de comédie étudiant. La composition est une sorte de relation plus stricte. Lors de l'utilisation de la composition, un objet fait partie d'un objet et ne peut pas appartenir à un autre objet du même type. L'exemple le plus simple est un moteur de voiture. Un moteur fait partie d'une voiture et ne peut pas faire partie d'une autre voiture. Comme vous pouvez le voir, leur relation est beaucoup plus stricte que la relation entre Caret Passengers.