L'héritage possède deux caractéristiques pouvant parfois être en contradiction:
class B extends A { ... }
class C extends A { ... }
| A | B, C |
|---|---|
| base | dérivée |
| mère, parente | fille |
| super-classe | sous-classe |
| qui est hérité | qui hérite |
| qui est étendue | qui étend |
| type, sur-type | sous-type |
La classe dérivée hérite des membres non marqués private de la classe de base (mis à part les constructeurs). Cette classe peut elle-même posséder des champs et méthodes supplémentaires. C'est le principe de l'extension, suggéré par le mot-clé extends.
Le mot-clé protected au-devant des membres de la classe de base permet d'élargir leur accès à toutes les classes dérivées.
Observez les fichiers Point.java et Vecteur.java.
L'héritage modélise aussi la relation dans laquelle un objet de la classe dérivée peut être utilisé comme un objet de la classe de base, c'est ce qui fait de l'héritage un mécanisme complexe.
class B extends A { ... }
B objetB = new B();
A objetA = new B(); //transtypage ascendant implicite
Un objet de la classe B est un objet de la classe A et peut être utilisé comme tel.
Attention: cette relation n'est pas symétrique.
objetA.methodeA(); //compile
objetB.methodeA(); //compile (extension de code)
objetA.methodeB(); //ne compile pas (objetA est de type A)
objetB.methodeB(); //compile (objetB est de type B)
Vous connaissez le transtypage ascendant (= upcast) implicite:
A objetA = new B(); //transtypage ascendant implicite
A l'inverse, il est possible de réaliser explicitement un transtypage descendant (= downcast):
B objetB2 = (B) objetA; //transtypage descendant explicite
C'est utile quand on manipule une instance de B comme un A (passage de paramètres par exemple), mais qu'on a besoin d'appeler methodeB.
A l'exécution, la machine virtuelle choisit la méthode à appeler en réponse à une requête, c'est le principe de la liaison dynamique.
La recherche de cette méthode commence avec la classe de l'objet auquel la requête est adressée. Si aucune méthode appropriée n'est trouvée, la recherche se poursuit dans la classe parente et ainsi de suite jusqu'à ce qu'une méthode soit trouvée (le compilateur a préalablement vérifié qu'il y aura toujours ultimement une méthode appropriée).
Dans une classe, on peut définir plusieurs méthodes ayant le même nom, pourvu que leurs signatures soient différentes.
L'intérêt est de faciliter l'écriture du code client et de fournir des valeurs par défaut pour certains arguments. Par exemple, un réel pur est un nombre complexe n'ayant qu'une partie réelle (la partie imaginaire est à zéro). Il est donc naturel de pouvoir appliquer les opérations non seulement sur des complexes, mais aussi sur des réels.
Dans une classe fille, il est possible de redéfinir certaines méthodes dont elle hérite pour les implémenter d'une autre manière. En réponse à un appel à methodeAB adressé à objetB, ce sera la code de la classe B qui sera exécuté (et non celui de la classe A).
Ne pas confondre redéfinition (= overriding), même signature, mais corps différent entre la classe de base et la classe dérivée, et surcharge (= overloading), même nom, mais signature différente, au sein d'une même classe.
En Java, toutes les classes dérivent par défaut de java.lang.Object (cf. l'API standard). Cette classe possède quelques méthodes pouvant être redéfinies comme toString qui retourne une représentation textuelle de type String de l'objet (nom de la classe, arobase, hash code par défaut).
Vous avez peut-être remarqué que le résultat de la somme de deux nombres complexes est de type Vecteur, car la méthode ajouter appelée est celle de la classe Vecteur.
//a et b sont de type Complexe
Vecteur vsum = a.ajouter(b); //compile
Complexe csum = a.ajouter(b); //ne compile pas
C'est embêtant si on veut enchaîner les opérations: multiplier la somme obtenue par un autre nombre complexe, par exemple, car dans ce cas il faut absolument un objet de type Complexe.
Dans la classe Complexe,
- surchargez le constructeur pour obtenir un nombre complexe à partir d'un vecteur,
- ajoutez les méthodes ajouter et retirer avec le type de retour Complexe. Il suffit pour cela de constuire un nombre complexe à partir du vecteur retourné par les méthodes ajouter et retirer de la classe parente. Dans du code client, vérifiez avec une instruction du type:
//a et b sont de type Complexe
Complexe sum = a.ajouter(b);