Course Module 2 : Java Core - Lecture: Héritage multiple d'interfaces

« Bonjour, Amigo ! Nous abordons enfin quelque chose de vraiment intéressant. Aujourd'hui, je vais te parler de l'héritage multiple. L'héritage multiple est en effet un outil très fascinant et puissant. Et s'il n'y avait pas un certain nombre de problèmes à cela, Java prendrait en charge l'héritage multiple de classes. Mais ce n'est pas le cas, et nous devons donc nous contenter de l'héritage multiple d'interfaces. Ce qui est également assez génial. »

Imagine que tu crées un jeu vidéo. Et ses personnages (tes objets) doivent se comporter de manière très complexe : se déplacer sur une carte, recueillir des objets, effectuer des quêtes, communiquer avec d'autres personnages, tuer quelqu'un, sauver quelqu'un d'autre. Disons que tu as réussi à diviser tous les objets en 20 catégories. Cela signifie que, si tu as de la chance, tu réussiras à t'en tirer avec seulement 20 classes pour définir tes objets. Mais voici le hic : combien de formes uniques d'interaction auront ces objets ? Chaque type d'objet peut avoir des interactions uniques avec 20 autres types d'objets (nous comptons également les interactions avec les objets du même type). En d'autres termes, tu devras écrire du code pour 20 x 20 = 400 interactions ! Et si le nombre de types d'objets uniques n'est pas 20, mais 100, le nombre d'interactions pourrait être de 10 000 !

« Ouah ! Maintenant je comprends pourquoi la programmation est un travail si difficile. »

« C'est simple. Grâce à beaucoup d'abstraction. Et en grande partie grâce à l'héritage multiple d'interfaces. »

Nous pouvons souvent simplifier l'interaction entre objets si ce sont les rôles et/ou capacités qui interagissent plutôt que les objets eux-mêmes. Et comme nous le savons déjà, les capacités peuvent facilement être ajoutées à une classe quand elle implémente une interface.

Lors de la rédaction d'un grand programme, les développeurs font habituellement cela au tout début :

1) Identifier toutes les capacités et tous les rôles.

2) Définir l'interaction entre ces rôles.

3) Puis simplement affecter des rôles à toutes les classes.

« Un exemple, peut-être ? »

« Bien sûr. Observons les rôles dans le dessin animé 'Tom et Jerry'. »

Code Java	Description
`interface Moveable {}`	- Rôle/capacité à se déplacer.
`interface Eatable {}`	- Rôle/capacité à être mangé.
`interface Eat {}`	- Rôle/capacité à manger quelqu'un.
`class Tom extends Cat implements Moveable, Eatable, Eat {}`	Tom est un chat qui a trois rôles : 1) Il peut se déplacer 2) Il peut manger quelqu'un 3) Il peut se faire manger par quelqu’un (un chien)
`class Jerry extends Mouse implements Moveable, Eatable {}`	Jerry est une souris qui a deux rôles : 1) Il peut se déplacer 2) Il peut se faire manger par quelqu'un
`class Killer extends Dog implements Moveable, Eat {}`	Killer est un chien qui a deux rôles : 1) Il peut se déplacer 2) Il peut manger quelqu'un

En connaissant seulement ces trois rôles (interfaces), tu peux écrire un programme et décrire l'interaction correcte entre ces rôles. Par exemple, un objet chassera (via l'interface Moveable) un personnage 'qui peut être mangé' et s'enfuir face à un personnage 'qui peut manger'. Et tout cela sans rien savoir sur des objets spécifiques. Si tu ajoutes d'autres objets (classes) au programme et conserves ces rôles, tout fonctionnera toujours parfaitement, en contrôlant le comportement de tes objets.