Héritage multiniveau en Java

L'héritage est l'une des caractéristiques importantes des concepts OOPS. Il facilite la réutilisation du code en héritant des fonctionnalités d'une classe appelée classe parent par une autre classe appelée classe enfant. Lorsque l’héritage s’étend à plus de 2 niveaux, on parle d’héritage multiniveau. Lorsqu’une nouvelle classe dérive des fonctionnalités d’une classe dérivée d’une classe de base, on parle d’héritage à plusieurs niveaux. On dit que la nouvelle classe est un petit-enfant d'une classe parent.

PUBLICITÉ Cours populaire dans cette catégorie MAÎTRISÉE JAVA - Spécialisation | 78 séries de cours | 15 tests simulés

Par exemple, A est le parent, la classe B est son enfant, et C est la classe enfant de B et petit-enfant de A. De même, A est la classe parent de la classe B et le grand-parent de la classe C.

Syntaxe de l'héritage multiniveau en Java

Voyons la syntaxe de l'héritage multiniveau en java qui est donnée ci-dessous :

class A{
//class A is parent of class B
//class A is grand parent of class C
public A(){
//A constructor
}
public void fun1(){
//function in Parent Class
}
}
class B extends A{
//class B is a child class of class A
//class B is a parent class of class C
public B(){
//class B constructor
}
}
class C extends B{
//class C is a child class of class B
//class C is grand child class of class A
public C(){
//Class C constructor
}
}
public class Test{
public static void main(String[] args){
C obj = new C();
}
}

Pour la mise en œuvre de l'héritage multiniveau, il doit y avoir une classe de base, par exemple A. Ensuite, il doit y avoir une classe dérivée B qui étend la classe A, et la classe C étend A.

Comment fonctionne l'héritage multiniveau en Java ?

L'héritage multiniveau est un type d'extension des fonctionnalités d'une classe dérivée à une autre nouvelle classe. Étant donné que les fonctionnalités de la classe parent sont étendues jusqu'à plusieurs niveaux, ce type d'héritage est appelé héritage multiniveau. Lorsqu'une classe enfant étend une classe parent, elle peut utiliser toutes les fonctionnalités de la classe parent. Ainsi, s'il existe une classe qui étend les fonctionnalités de cette classe dérivée, alors on dit qu'elle est un petit-enfant de la classe de base qui possède toutes les fonctionnalités des classes parent et enfant.

Considérez une classe A comme classe parent, la classe B comme classe enfant de la classe A et la classe C comme classe enfant de la classe B. et lorsqu'un objet est créé pour la classe C, dites obj comme indiqué ci-dessus. Lorsque l'on déclare cet objet, le constructeur de la classe C est appelé. Comme nous le savons, lorsque le constructeur d'une classe enfant est appelé, le premier constructeur de sa classe parent est appelé. Ainsi, lorsque nous appelons C() – alors le constructeur B() est appelé, et de plus, comme B est une classe enfant de la classe B, donc A() est appelé. Ensuite, le contrôle revient à la classe enfant. Ainsi dans la série suivante, les constructeurs sont exécutés :

A() – > B() – > C()

Mais lorsqu'une méthode est appelée en utilisant cet objet d'une classe enfant, on vérifie d'abord si cette méthode avec la même signature est présente dans la classe enfant. Sinon, le contrôle est dirigé vers sa classe parent pour trouver la méthode. Ainsi, dans ce cas, lorsque fun1() est appelé à l’aide de l’objet obj, le contrôle passe en C et constate qu’une telle méthode n’existe pas ; ainsi, le contrôle passe à B et donc à la classe A.

La raison en est que l'on peut facilement redéfinir les méthodes de la classe parent dans sa classe enfant, ce que l'on appelle le remplacement de méthode. Ainsi, la première préférence est donnée à la méthode remplacée. De cette manière, l'héritage multiniveau implémente la fonctionnalité d'héritage dans les classes à plusieurs niveaux. Ce type d'héritage est le plus souvent utilisé lors de la mise en œuvre de l'augmentation des données, c'est-à-dire le processus d'augmentation de la diversité et de la quantité de données existantes sans mettre à jour le code existant. Cela permet également d’introduire de la variabilité dans le modèle de formation disponible en appliquant des transformations simples.

Exemples d'héritage à plusieurs niveaux

Voyons quelques exemples d'héritage multiniveau en Java.

Code :

class Electronics {
public Electronics(){
System.out.println("Class Electronics");
}
public void deviceType() {
System.out.println("Device Type: Electronics");
}
}
class Television extends Electronics {
public Television() {
System.out.println("Class Television");
}
public void category() {
System.out.println("Category - Television");
}
}
class LED extends Television {
public LED() {
System.out.println("Class LED");
}
public void display_tech() {
System.out.println("Display Technology- LED");
}
}
public class Tester {
public static void main(String[] arguments) {
LED led = new LED();
led.deviceType();
led.category();
led.display_tech();
}
}

Sortie :

Explication : Dans l'exemple ci-dessus, la classe Electronics est une classe générale qui fournit une méthode device_type() pour tous les appareils électroniques. Ensuite, nous avons la classe Television qui étend la classe Electronics, qui spécifie le périphérique électronique et possède un nom de méthode –category() pour afficher le type de périphérique électronique. Ensuite la classe LED étend la classe Télévision pour préciser la technologie utilisée pour son affichage. Il a la méthode display_tech() pour montrer que la technologie est LED.

Dans la méthode main, lorsque nous créons un objet de la classe LED, nous l'utilisons pour appeler la méthode pour toute la classe parent. Lorsqu’il faut appeler le constructeur d’une classe enfant, le constructeur de la classe parent est appelé en premier ; ainsi, lorsque new LED() est appelé, le premier new Television() est appelé. Plus loin dans ce constructeur, new Electronics() est appelé et affiche – Class Electronics.

Ensuite, il est renvoyé au constructeur de télévision et affiche la classe Télévision, puis renvoyé à la classe LED et affiche la classe LED. Lorsqu'une méthode est appelée à l'aide d'un objet de la classe LED, le premier contrôle va à la classe LED et essaie de trouver la méthode – device_type() et est allé à la classe Television pour trouver la méthode si elle ne la trouve pas dans la classe LED et plus loin lorsqu'elle n'est pas trouvée. en classe Télévision va également à sa superclasse électronique supplémentaire, trouve cette méthode et l'exécute.

Conclusion

L'héritage multiniveau est une excellente technique pour mettre en œuvre le principal avantage de l'héritage, à savoir la réutilisabilité et la lisibilité du code à travers plusieurs niveaux. Il contribue à introduire de la variabilité et de la diversité dans le code existant, qui fournit le matériel de formation de base. Cette procédure est connue sous le nom de documentation du code.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!