La programmation orientée objet
Partie 4 sur 5
8L’héritage
8.1Principe
L’héritage (en anglais inheritance), parfois appelé dérivation de classe, est un mécanisme qui permet de créer une nouvelle classe à partir d’une classe existante. La classe dérivée, nouvellement créée, contient les attributs et les méthodes de sa superclasse, la classe dont elle dérive ; on peut lui ajouter de nouveaux attributs et de nouvelles méthodes, qui s’ajoutent à ceux et celles hérités, ou modifier certaines méthodes héritées. On crée ainsi une hiérarchie de classes de plus en plus spécialisées, sans repartir de zéro lorsqu’on veut spécialiser une classe existante. Une conséquence commerciale en découlait : on pouvait acheter des bibliothèques de classes servant de base, et les spécialiser à loisir ; ce rôle est aujourd’hui tenu surtout par les frameworks, souvent libres (voir les bibliothèques et les frameworks).
8.2La hiérarchie des classes
On représente la relation de parenté entre les classes sous la forme d’une hiérarchie, ou arborescence, de classes (figure 3). Elle commence par une classe générale, appelée superclasse, ou encore classe de base, classe parente, classe ancêtre, classe mère ou classe père : les métaphores généalogiques sont nombreuses. Les classes dérivées, appelées classes filles ou sous-classes, sont de plus en plus spécialisées. La relation qui lie une classe fille à sa mère s’exprime par la phrase « est un » (en anglais is a) : un cavalier est une pièce d’échecs, une voiture est un véhicule. Si la phrase sonne faux, l’héritage est probablement mal employé.
On voit dans la conception de cette hiérarchie « le travail principal du programmeur Java » : organiser les classes de telle façon que les attributs et méthodes communs à plusieurs classes soient placés dans une superclasse. Une modification de la superclasse se répercute automatiquement sur toutes les sous-classes : c’est un avantage, mais aussi un risque, connu sous le nom de « classe de base fragile », car une modification anodine en haut de la hiérarchie peut casser des sous-classes qu’on ne connaît pas.
8.3L’héritage en Java
En Java, on fait hériter une classe d’une autre avec le mot-clé extends. Toute classe hérite, au minimum, d’une « super-superclasse » nommée Object : écrire class Article { } revient à écrire class Article extends Object { }. L’arborescence est stricte : une classe ne peut avoir qu’une seule superclasse, on parle d’héritage simple, mais elle peut avoir un nombre illimité de sous-classes. Lorsqu’on instancie une classe, l’objet reçoit l’ensemble des attributs et des méthodes de sa superclasse, qui elle-même hérite de sa propre superclasse, et ainsi de suite.
De même que this désigne l’objet courant, le mot-clé super désigne la partie héritée de la superclasse : super.nomAttribut pour un attribut, super.nomMethode() pour une méthode, et super(parametre1, parametre2), en première ligne d’un constructeur, pour appeler le constructeur de la classe parente.
class Vehicule {
protected int vitesse;
Vehicule(int vitesse) { this.vitesse = vitesse; }
String decrire() { return "Véhicule à " + vitesse + " km/h"; }
}
class Voiture extends Vehicule {
private String marque;
Voiture(String marque, int vitesse) {
super(vitesse); // constructeur de Vehicule
this.marque = marque;
}
@Override
String decrire() {
return super.decrire() + ", de marque " + marque; // ajoute un comportement
}
}
Une sous-classe peut redéfinir totalement une méthode héritée, en la réécrivant avec le même nom et les mêmes types de paramètres : la méthode d’origine est alors ignorée au profit de la nouvelle. Elle peut aussi simplement ajouter un comportement au comportement d’origine, comme dans l’exemple : elle appelle alors la méthode de la superclasse, par super.decrire(), et ajoute ses propres instructions. On parle parfois, à tort, d’appeler pour cela « le constructeur de la superclasse » : c’est bien la méthode de la superclasse qu’on appelle. L’annotation @Override demande au compilateur de vérifier qu’une méthode redéfinit bien une méthode existante.
8.4L’héritage multiple
Certains langages, comme le C++ ou Python, permettent l’héritage multiple : une classe peut hériter de plusieurs superclasses, et regrouper ainsi leurs attributs et leurs méthodes. La technique est puissante mais délicate : si deux superclasses ont une méthode de même nom, laquelle hériter ? Et si elles héritent toutes deux d’une même classe, la classe finale en contient-elle deux copies ? C’est le célèbre « problème du losange ». Java et C# l’évitent en n’autorisant qu’une superclasse, mais permettent à une classe d’implémenter plusieurs interfaces (section 9).
8.5Hériter ou composer ?
L’héritage n’est pas le seul moyen de réutiliser du code. La composition consiste à construire un objet à partir d’autres objets qu’il contient : une voiture a un moteur, elle n’est pas un moteur. Elle correspond à l’agrégation, citée parmi les concepts de Smalltalk. Les concepteurs expérimentés recommandent souvent de préférer la composition à l’héritage, plus souple et moins fragile, et de réserver l’héritage aux véritables relations « est un ».
9Le polymorphisme
Le mot polymorphisme vient du grec et signifie « qui peut prendre plusieurs formes ». C’est l’un des concepts essentiels de la POO. Alors que l’héritage concerne les classes et leur hiérarchie, le polymorphisme concerne les méthodes et les opérations. On en distingue généralement trois formes, et beaucoup de confusions existent à leur sujet ; l’une d’elles, fréquente, est corrigée ici.
9.1Le polymorphisme ad hoc : la surcharge
Le polymorphisme ad hoc, ou surcharge (en anglais overloading), consiste à définir plusieurs fonctions de même nom, mais possédant des paramètres différents, en nombre ou en type. On peut ainsi définir plusieurs méthodes addition() : int addition(int, int) renvoie la somme de deux entiers, float addition(float, float) celle de deux nombres à virgule, et char addition(char, char) ce que l’auteur aura décidé pour deux caractères. On appelle signature d’une méthode son nom, ainsi que le nombre et le type de ses paramètres ; c’est la signature qui permet au compilateur de choisir, automatiquement, la bonne méthode en fonction du type des données passées en paramètre.
La surcharge s’applique aussi aux opérateurs, dans les langages qui le permettent, comme le C++, le C# ou Python : l’opérateur + peut réaliser une addition entre deux nombres, et une concaténation, c’est-à-dire une mise bout à bout, entre deux chaînes de caractères. On présente parfois les fonctions de même nom à paramètres différents comme du polymorphisme « paramétrique » : il s’agit en réalité de surcharge, donc de polymorphisme ad hoc.
On range aussi parfois dans le polymorphisme ad hoc le fait que des classes sans rapport entre elles, une classe Complexe, une classe Image et une classe Lien, aient chacune une méthode afficher(), ce qui permet d’afficher un objet sans se soucier de son type. Dans les langages à typage dynamique comme Python ou JavaScript, cela fonctionne directement : il suffit que l’objet possède la méthode appelée, c’est ce qu’on appelle le « typage canard » (« si ça marche comme un canard et que ça cancane comme un canard, c’est un canard »). Dans les langages à typage statique, on obtient le même résultat en faisant implémenter à ces classes une interface commune (section 9.4).
9.2Le polymorphisme paramétrique : la généricité
Le polymorphisme paramétrique, ou généricité, permet d’écrire un seul code qui fonctionne avec n’importe quel type, le type étant lui-même un paramètre. Une liste générique, List<T> en Java ou en C#, se décline en liste de chaînes, List<String>, ou de voitures, List<Voiture>, sans réécrire la classe, et le compilateur vérifie qu’on n’y range que des éléments du bon type (exercice 4). En C++, on parle de patrons (en anglais templates).
9.3Le polymorphisme d’héritage : la redéfinition
La possibilité de redéfinir une méthode dans les classes qui héritent d’une classe de base s’appelle la spécialisation, ou redéfinition (en anglais overriding). On peut alors appeler la méthode d’un objet sans se soucier de son type exact : c’est le polymorphisme d’héritage, ou d’inclusion. Il permet de faire abstraction des détails des classes spécialisées d’une famille d’objets, en les masquant derrière une interface commune, celle de la classe de base.
Prenons l’exemple d’un jeu d’échecs comportant des objets roi, reine, fou, cavalier, tour et pion, héritant tous d’une classe pièce (figure 3). La méthode mouvement() effectue, grâce au polymorphisme d’héritage, le déplacement approprié selon la classe réelle de l’objet au moment de l’appel : le programme peut écrire piece.mouvement() sans se préoccuper du type de la pièce. Le choix de la bonne méthode se fait pendant l’exécution, et non à la compilation ; on parle de liaison dynamique.
9.4Classes abstraites et interfaces
Dans l’exemple des échecs, il n’existe pas de « pièce » qui ne soit ni un roi, ni une reine, ni aucune autre : la classe Piece est abstraite. Une classe abstraite ne peut pas être instanciée ; elle peut déclarer des méthodes abstraites, sans code, que chaque sous-classe doit obligatoirement définir. Une interface va plus loin : elle ne décrit qu’un ensemble de méthodes, un contrat, que les classes qui l’implémentent s’engagent à fournir. Une classe Java peut implémenter plusieurs interfaces, par exemple Comparable, pour pouvoir être triée, et Serializable, pour pouvoir être enregistrée. Programmer en s’appuyant sur des interfaces plutôt que sur des classes concrètes est l’un des principes clés d’une conception souple.
Pour s’exercer
Exercice 3 : quelle méthode est appelée ?
Une classe Java Calcul définit int addition(int a, int b) et double addition(double a, double b). Quelle méthode est appelée par addition(2, 3), addition(2.5, 1.0) et addition(2, 1.5) ? De quelle forme de polymorphisme s’agit-il ?
Voir la réponse
addition(2, 3) appelle la version entière, qui renvoie 5. addition(2.5, 1.0) appelle la version à virgule, qui renvoie 3.5. addition(2, 1.5) : aucune signature ne correspond exactement ; Java convertit l’entier 2 en 2.0 et appelle la version à virgule, qui renvoie 3.5. C’est du polymorphisme ad hoc, ou surcharge : le choix est fait par le compilateur, d’après la signature.
Exercice 4 : l’intérêt de la généricité
Avant 2004, Java n’avait pas de généricité : une liste contenait des objets de type Object. Quel problème pose le code suivant, et comment la généricité le résout-elle ? List noms = new ArrayList(); noms.add("Momo"); noms.add(42); String s = (String) noms.get(1);
Voir la réponse
La liste accepte n’importe quel objet, y compris l’entier 42. La conversion forcée (String) de l’élément numéro 1 échoue à l’exécution, en levant une exception : l’erreur n’est découverte qu’au moment où le programme tourne, peut-être chez un client. Avec la généricité, List<String> noms = new ArrayList<>();, le compilateur refuse noms.add(42) : l’erreur est détectée avant même l’exécution, et la conversion devient inutile.
Exercice 5 : égalité et identité
En Java, on crée Personne a = new Personne(30); Personne b = new Personne(30); Personne c = a;. Que valent a == b, a == c ? Que devient a.getAge() après c.setAge(40) ?
Voir la réponse
a == b est faux : l’opérateur == compare les références, et a et b désignent deux objets distincts, même s’ils ont le même âge, comme deux tee-shirts identiques. Pour comparer leurs valeurs, on définit une méthode equals(). a == c est vrai : c est une seconde référence vers le même objet. Après c.setAge(40), a.getAge() renvoie donc 40 (figure 2).
Exercice 6 : un mutateur trop confiant
Considérons ce mutateur : int setAge(int nouveauAge) { if (nouveauAge < 200) { age = nouveauAge; return 1; } else return 0; }. Trouvez deux faiblesses.
Voir la réponse
1) Il accepte les âges négatifs : setAge(-5) renvoie 1 et enregistre −5. Il faut tester aussi la borne inférieure. 2) Il signale l’erreur par un code de retour, 0, que l’appelant peut ignorer sans s’en rendre compte : l’objet n’est pas modifié, et personne n’est prévenu. Lever une exception, comme dans la version de la section 6.3, oblige à traiter l’erreur. On pourrait ajouter que la borne de 200 ans est une hypothèse arbitraire, qu’il vaut mieux définir comme une constante nommée.