13.4 Héritage et polymorphisme en Java : utilisation de « super » pour accéder aux membres de la superclasse
L'héritage est l'un des piliers fondamentaux de la programmation orientée objet (POO), et Java, étant un langage qui adopte ce paradigme, offre des mécanismes robustes pour le mettre en œuvre. L'héritage permet à une classe d'hériter des caractéristiques d'une autre classe, favorisant la réutilisation du code et la création d'une hiérarchie de classes. Le polymorphisme, quant à lui, est la capacité d'un objet à être référencé de diverses manières, principalement via sa classe de base ou ses interfaces. Ces deux concepts sont essentiels pour comprendre et développer des applications Java efficaces.
Lorsqu'une classe hérite d'une autre, la classe dont elle hérite est appelée une sous-classe, tandis que la classe dont elle hérite est appelée une superclasse. La sous-classe hérite des champs et des méthodes de la superclasse et peut également ajouter de nouveaux champs et méthodes ou remplacer les méthodes héritées. Cependant, il peut y avoir des situations où la sous-classe souhaite accéder aux membres (champs ou méthodes) de la superclasse. C'est là que l'utilisation du mot-clé super devient pertinente.
Accéder aux membres de la superclasse avec « super »
Le mot-clé super en Java est utilisé dans une sous-classe et sert à référencer directement la superclasse immédiate. Il est principalement utilisé dans trois situations :
- Pour appeler le constructeur de superclasse.
- Pour accéder à un membre de la superclasse qui a été masqué par la sous-classe (par exemple, un champ du même nom).
- Pour appeler une méthode de superclasse qui a été remplacée par la sous-classe.
Appel du constructeur de superclasse
Lorsqu'une sous-classe est instanciée, le constructeur de la superclasse est appelé avant le constructeur de la sous-classe. Si la superclasse n'a pas de constructeur sans argument (c'est-à-dire un constructeur par défaut), vous devrez appeler explicitement un constructeur spécifique à la superclasse en utilisant super. Cela se fait dans la première ligne du constructeur de sous-classe :
Base de classe {
Base(int x) {
System.out.println("Constructeur de base avec la valeur " + x);
}
}
la classe dérivée étend la base {
Dérivée (int x, int y) {
super(x); // Appel du constructeur de la classe Base
System.out.println("Constructeur dérivé avec la valeur " + y);
}
}
Accès aux membres cachés de la superclasse
Si une sous-classe définit un champ portant le même nom qu'un champ de superclasse, le champ de superclasse est masqué dans la sous-classe. Pour accéder au champ caché de la superclasse, vous pouvez utiliser super :
Base de classe {
numéro entier ;
}
la classe dérivée étend la base {
numéro entier ;
void setNumber (numéro int) {
this.number = nombre ; // Attribue au champ de sous-classe
super.numéro = nombre + 10 ; // Attribue au champ de superclasse
}
}
Invocation de méthodes remplacées par une superclasse
Lorsqu'une sous-classe remplace une méthode de superclasse, elle peut toujours appeler la version de la méthode de la superclasse en utilisant super. Ceci est utile lorsque vous souhaitez étendre les fonctionnalités de la méthode substituée, plutôt que de la remplacer complètement :
Base de classe {
spectacle vide() {
System.out.println("Afficher depuis la base");
}
}
la classe dérivée étend la base {
spectacle vide() {
super.show(); // Appel de la méthode show() de la superclasse
System.out.println("Afficher le dérivé");
}
}
Polymorphisme et héritage
Le polymorphisme en Java est étroitement lié à l'héritage. Grâce au polymorphisme, les objets d'une sous-classe peuvent être traités comme des objets de la superclasse. Cela permet d'utiliser des méthodes ou des variables de référence de la superclasse pour référencer des objets de n'importe quelle sous-classe, permettant ainsi l'exécution de méthodes remplacées spécifiques à la sous-classe. La décision concernant la méthode à invoquer est prise au moment de l'exécution (liaison tardive), connue sous le nom de polymorphisme d'exécution ou polymorphisme dynamique.
Par exemple, considérons une superclasse appelée Animal et les sous-classes Dog et Cat. Si les deux sous-classes remplacent une méthode makeSound() de la superclasse, une méthode qui reçoit une référence de Animal peut invoquer makeSound() et le son sera produit selon que l'objet référencé est un Chien ou un Chat.
classe Animal {
void makeSound() {
System.out.println("Sons d'animaux génériques");
}
}
la classe Chien étend Animal {
void makeSound() {
System.out.println("Oof ouf");
}
}
la classe Chat étend Animal {
void makeSound() {
System.out.println("Miaou");
}
}
classe publique TestPolymorphisme {
public static void main (String[] arguments) {Animal monAnimal = new Dog();
monAnimal.makeSound(); // Produira "Woof woof"
monAnimal = nouveau Chat();
monAnimal.makeSound(); // Produira "Miaou"
}
}
Cet exemple illustre la flexibilité et la puissance du polymorphisme en Java, où l'implémentation spécifique d'une méthode est déterminée par le type réel de l'objet et non par le type de la variable de référence.
Conclusion
L'héritage et le polymorphisme sont des concepts clés de la programmation orientée objet et sont largement utilisés en Java pour créer des programmes flexibles et réutilisables. Le mot-clé super joue un rôle important dans l'héritage, permettant aux sous-classes d'interagir avec les membres de la superclasse de manière contrôlée. Le polymorphisme, quant à lui, permet d'interagir avec des objets de différentes classes via une interface commune. Comprendre ces concepts et savoir comment les appliquer est fondamental pour tout programmeur Java souhaitant créer des systèmes robustes et maintenables.
