types inheritance java single vs multiple inheritance
Apprenez tout sur les différents types d'héritage en Java à l'aide d'exemples simples. Découvrez si Java prend en charge l'héritage multiple:
Nous avons présenté l'héritage en Java ainsi que les différents concepts de base liés à l'héritage aux lecteurs dans notre dernier tutoriel.
Dans ce didacticiel, nous explorerons plus en détail le sujet de l'héritage et en apprendrons plus sur les types d'héritage.
=> Consultez TOUS les didacticiels Java ici.
quelles sont les bases de la programmation informatique
Ce que vous apprendrez:
Types d'héritage en Java
En fonction de la façon dont les classes sont héritées et du nombre de classes héritées, nous avons les types d'héritage suivants, comme illustré dans la figure ci-dessous.
Comme le montre la figure ci-dessus, il existe cinq types d'héritage dans la programmation orientée objet, comme décrit ci-dessous:
# 1) Héritage unique: Lorsqu'une classe ou sous-classe dérivée hérite d'une seule base ou superclasse, il s'agit d'un héritage unique.
# 2) Héritage à plusieurs niveaux: Dans l'héritage à plusieurs niveaux, nous avons plus d'un niveau dans lequel une classe hérite d'une classe de base et la classe dérivée à son tour est héritée par une autre classe.
# 3) Héritage hiérarchique: Une hiérarchie d'héritage est formée dans ce type d'héritage lorsqu'une superclasse est héritée par plus d'une classe.
# 4) Héritage multiple: L'héritage multiple est celui dans lequel une classe peut hériter des propriétés et du comportement de plusieurs parents.
# 5) Héritage hybride: Lorsqu'un ou plusieurs types d'héritage sont combinés, cela devient un héritage hybride.
Notez que Java ne prend en charge que les types d'héritage à un, plusieurs niveaux et hiérarchiques utilisant des classes. Java ne prend pas en charge l'héritage multiple et hybride avec les classes.
Nous allons maintenant discuter de chaque type d'héritage en détail avec des exemples de programmation.
Héritage unique en Java
Un héritage unique est représenté comme indiqué ci-dessous:
Ici, une sous-classe hérite d'une seule superclasse. Il s'agit d'un héritage unique. Tout animal comme le chien hérite de l'espèce animale. C'est la forme la plus simple d'héritage.
Ci-dessous, un programme Java expliquant l'héritage unique.
//base class:Animal class Animal { void Action_eat() { System.out.print('eating...'); } } //derived class:Dog class Dog extends Animal { void Action_bark() { System.out.print('barking...'); } } class Main{ public static void main(String args()){ Dog d=new Dog(); //create an object of derived class System.out.print('The dog is '); d.Action_bark(); //call derived class method System.out.print('
The dog is '); d.Action_eat(); //call base class method } } Production:
Ici, nous avons une méthode eat (Action_eat) dans la classe de base Animal qui est commune aux espèces animales. Nous avons une classe dérivée Dog qui dérive de la classe Animal. Dans la classe Dog, nous avons une méthode spécifique aux espèces Dog, bark (Action_bark).
Ensuite, nous créons un objet Dog dans la méthode main et comme la classe Dog a hérité de la classe Animal, cet objet peut appeler la méthode eat ainsi que la méthode bark.
Héritage à plusieurs niveaux en Java
Dans l'héritage multi-niveaux, nous avons une chaîne d'héritage. Cela signifie que nous avons une classe parent héritée par une classe dérivée. La classe dérivée agit à son tour comme un parent d'une autre classe et ainsi de suite.
L'héritage multi-niveaux peut être représenté comme ci-dessous:
Comme le montre la figure ci-dessus, il existe une classe parent A. La classe B hérite de la classe A. Ensuite, il y a une autre classe C qui hérite à son tour de la classe B. Ainsi, nous pouvons voir qu'elle forme une chaîne d'héritage. Ici, la classe B devient une classe intermédiaire qui relie les classes A et C.
En continuant avec notre exemple de classe Animal ci-dessous, nous pouvons avoir une classe Dog dérivée de la classe Animal. Ensuite, nous pouvons avoir une autre classe Puppy qui est un bébé chien dérivé de la classe Dog. De cette façon, nous pouvons avoir l'héritage à plusieurs niveaux.
Un exemple de programme pour l'héritage à plusieurs niveaux est illustré ci-dessous.
import java.util.*; import java.lang.*; import java.io.*; //parent class A class A { public void print_A() { System.out.print('SoftwareTestingHelp '); } } //Derived class B - intermediary class B extends A { public void print_B() { System.out.print('Java Series '); } } //Derived Class C class C extends B { public void print_C() { System.out.print('Tutorials'); } } public class Main { public static void main(String() args) { C c_obj = new C(); //create Class C obj c_obj.print_A(); //call grandparent class method c_obj.print_B(); //call parent class method c_obj.print_C(); //call member method } }Production:
Nous avons programmé la chaîne exacte indiquée ci-dessus. Puis dans la méthode principale, on crée un objet de classe C. L'objet de classe C peut alors accéder aux méthodes de son parent B ainsi que de son grand-parent A.
Héritage hiérarchique en Java
Une classe peut en dériver plusieurs classes. Nous avons donc une base ou superclasse et plusieurs sous-classes. Ce type d'héritage est appelé «héritage hiérarchique».
L'héritage hiérarchique est représenté schématiquement ci-dessous:
À titre d'exemple d'héritage hiérarchique, nous pouvons représenter la classe animale comme une superclasse et en dériver plus d'un animal comme le chat, le chien, la vache, etc.
Le programme Java ci-dessous illustre l'héritage hiérarchique en Java.
//class Parent class Parent { public void print_parent() { System.out.println('In ::Parent class'); } } //child1 class class Child1 extends Parent { public void print_child1() { System.out.println('In ::Child1 class'); } } //child2 class class Child2 extends Parent { public void print_child2() { System.out.println('In ::Child2 class'); } } //child3 class class Child3 extends Parent { public void print_child3() { System.out.println('In ::Child3 class'); } } public class Main { public static void main(String() args) { Child1 ch1 = new Child1(); //create a Child1 class object ch1.print_child1(); //call its member method Child2 ch2 = new Child2(); //create a Child2 class object ch2.print_child2(); //call its member method Child3 ch3 = new Child3(); //create a Child3 class object ch3.print_child3(); //call its member method ch3.print_parent(); //call parent class method with any object } } Production:
Comme nous le voyons dans le programme, nous avons une classe parent et trois classes enfants dérivées de ce parent. Dans la méthode main, nous créons un objet de chacune des classes enfants et appelons leurs méthodes membres respectives.
Pour appeler les méthodes de la classe parent, notez que nous pouvons utiliser n'importe quel objet de classe enfant car tous ont accès à la classe parent.
Héritage multiple en Java
L'héritage multiple est une situation dans laquelle une classe peut hériter de plus d'une classe, c'est-à-dire qu'une classe peut avoir plus d'un parent. En faisant cela, la classe peut avoir plus d'une superclasse et ainsi acquérir les propriétés et le comportement de toutes ses superclasses.
La représentation schématique de l'héritage multiple est illustrée ci-dessous:
Comme indiqué ci-dessus, nous pouvons dériver une classe de plus d'une classe simultanément. De cette façon, la classe dérivée acquerra les caractéristiques de toutes ses classes parentes. Cela peut donner lieu à de sérieuses ambiguïtés, en particulier lorsque les caractéristiques héritées sont les mêmes.
Noter:Java ne prend pas en charge l'héritage multiple à l'aide de classes. Mais il prend en charge l'héritage multiple à l'aide d'interfaces dont nous parlerons dans notre prochain tutoriel sur l'héritage.
Puisque Java ne prend pas en charge l'héritage multiple avec des classes, nous n'entrerons pas dans les détails. Cependant, plus loin dans le didacticiel, nous essaierons de comprendre les raisons pour lesquelles Java ne prend pas en charge l'héritage multiple.
Héritage hybride en Java
L'héritage hybride est une combinaison d'un ou plusieurs types d'héritage dont nous avons discuté ci-dessus. Toute combinaison entraîne cependant un type d'héritage multiple qui n'est pas pris en charge par Java.
Un héritage hybride peut être représenté schématiquement comme ci-dessous.
Par conséquent, Java ne prend pas non plus en charge l'héritage hybride avec les classes. Mais comme l'héritage multiple, nous pouvons implémenter l'héritage hybride en Java à l'aide d'interfaces. Nous en discuterons en détail dans notre prochain tutoriel.
Pourquoi Java ne prend pas en charge l'héritage multiple?
Java vise la simplicité des programmes. Cela s'applique même aux fonctionnalités POO. Ainsi, lorsqu'il s'agit d'héritage multiple, certaines situations ambiguës peuvent survenir lorsque nous dérivons une classe à partir de plusieurs classes.
Voyons maintenant les problèmes qui peuvent survenir lorsque nous avons plusieurs héritages dans notre programme.
Considérez les systèmes d'héritage multiple suivants.
Si nous voyons le système ci-dessus, il est explicite. Ici, la classe A et la classe B sont des classes biparentales héritées de la classe C. Nous avons maintenant montré que les classes A et B ont une méthode avec le même nom, c'est-à-dire print (). Ainsi, lorsque la classe C hérite de A et B, elle obtiendra les deux versions de la méthode print ().
Dans ce cas, la classe C ne saura pas de quelle méthode elle doit hériter. C'est la situation ambiguë que nous avons mentionnée ci-dessus qui se présente dans le cas de l'héritage multiple.
Par conséquent, Java émet une erreur de compilation lorsque la classe hérite de plusieurs classes.
Le programme Java suivant le démontrera.
class A{ void print(){ System.out.println('Class A :: print()'); } } class B{ void print(){ System.out.println('Class B :: print()'); } } class C extends A , B{ //let C inherit from A and B } public class Main { public static void main(String() args) { C cObj = new C(); c.print(); } } Production:
Comme le montre la sortie, le compilateur Java émet une erreur lorsqu'il constate que la classe étend deux classes.
Bien que Java ne permette pas d'hériter de deux classes simultanément, il nous offre un moyen de contourner cette limitation. Nous pouvons simuler l'héritage multiple en utilisant des interfaces au lieu de classes. Nous en discuterons dans nos prochains tutoriels.
Problème de diamant
L'héritage multiple entraîne une situation appelée «problème de diamant».
Considérez que nous avons le système d'héritage suivant.
class Super{ void show(){} } class Sub1 extends super{ void show1(){} } class Sub2 extends super{ void show2(){} } class sample extends Sub1,Sub2{ //Sample class code here } Nous pouvons représenter ce système schématiquement comme indiqué ci-dessous:
Comme nous pouvons le voir sur le diagramme ci-dessus, l'ensemble du système d'héritage apparaît en forme de losange. En raison de cette structure en diamant, l'ambiguïté est appelée le «problème du diamant».
Comme expliqué précédemment pour l'héritage multiple, l'ambiguïté ici est le nombre multiple de copies de la méthode show () que la classe Sample obtient à la suite de l'héritage. Comme il y a plusieurs chemins, il réalise la méthode show () et il y a une ambiguïté concernant la copie à hériter.
Comme pour l'héritage multiple, le problème du diamant peut également être résolu à l'aide d'interfaces.
Règles d'héritage en Java
Jusqu'à présent, nous avons vu les bases de l'héritage ainsi que les types d'héritage en Java, énumérons quelques règles que nous devons suivre lors du développement d'applications avec héritage.
Règle n ° 1: Java ne prend pas en charge l'héritage multiple
Comme nous l'avons déjà vu, Java ne prend en charge l'héritage multiple sous aucune forme. Lorsque l'héritage multiple est tenté dans un programme, le compilateur Java émet une erreur de compilation.
Règle n ° 2: Java n'autorise pas l'héritage cyclique
Une classe qui hérite d'elle-même pour former un cycle s'appelle l'héritage cyclique.
Considérez les classes suivantes, class1 et class2.
class class1 étend la classe 2 {}
la classe classe2 étend la classe 1 {}
La situation ci-dessus forme une boucle. Ceci n'est pas autorisé en Java.
Règle n ° 3: nous ne pouvons pas hériter des membres de données privées
Nous avons déjà appris dans la rubrique «Modificateurs d'accès» que les membres disposant d'un accès privé ne peuvent pas être hérités.
Règle n ° 4: les constructeurs ne sont pas hérités
Les constructeurs étant utilisés pour créer des objets de classe, ils ne sont pas hérités d'une classe à une autre.
Règle n ° 5: nous pouvons utiliser la référence parent pour accéder aux objets enfants
Nous avons déjà vu divers exemples d'héritage. Nous pouvons créer une référence de type classe parent puis lui attribuer un objet de classe dérivé créé à l'aide du mot-clé new.
Si super est une superclasse et sub est une classe dérivée de super comme indiqué ci-dessous.
class super{} class sub extends super{ public static void main(String() args){ super s_obj = new sub(); } }Règle n ° 6: les constructeurs parents sont exécutés à cause de super () dans les constructeurs dérivés
L'une des règles stipule que les constructeurs ne peuvent pas être hérités. Mais le constructeur de la superclasse peut être exécuté à l'intérieur du constructeur de la classe dérivée en utilisant l'appel super ().
Questions fréquemment posées
Q # 1) Quel type d'héritage n'est pas pris en charge par Java?
Répondre: Java ne prend pas en charge l'héritage multiple car il peut donner lieu à des problèmes dans des applications comme le problème du diamant. Java ne prend pas non plus en charge l'héritage hybride car il s'agit d'une combinaison d'un ou plusieurs types d'héritage et peut finalement se transformer en héritage multiple.
Q # 2) Lequel des membres de la classe peut être hérité?
Répondre: Une classe peut hériter des membres publics et protégés de sa classe de base mais ne peut pas accéder aux membres privés de la classe de base.
Q # 3) Pourquoi l'héritage multiple n'est-il pas autorisé?
Répondre: L'héritage multiple entraîne une ambiguïté lorsque les classes biparentales ont des méthodes avec le même prototype. Dans ce cas, la classe dérivée est confrontée à une ambiguïté quant à la classe de base à partir de laquelle elle doit hériter de la méthode.
L'héritage multiple peut également entraîner un problème de diamant en Java. Par conséquent, Java ne prend pas en charge l'héritage multiple.
logiciel de sauvegarde en ligne pour les prestataires de services
Q # 4) Pourquoi avez-vous besoin d'héritage multiple?
Répondre: Des langages comme Java et C # imposent l'héritage multiple à l'aide de plusieurs interfaces. Ainsi, lorsque nous devons hériter des fonctionnalités de plusieurs interfaces, nous avons besoin d'un héritage multiple.
Q # 5) Quelle est l'utilisation principale de l'héritage à plusieurs niveaux?
Répondre: Une classe dérivée d'une autre classe qui à son tour est dérivée d'une troisième classe est censée présenter un héritage à plusieurs niveaux. Les niveaux de ce type d'héritage peuvent être étendus à n'importe quel nombre tant qu'il conserve clarté et simplicité.
Nous pouvons décrire différents niveaux d'espèces en utilisant l'héritage à plusieurs niveaux. Du point de vue de la programmation, lorsque nous voulons représenter différents niveaux de classes d'application, nous optons pour l'héritage multiniveau.
Conclusion
Dans ce tutoriel, nous avons discuté des types d'héritage en Java. Java ne prend en charge que les types d'héritage simple, multi-niveaux et hiérarchique. Java ne prend pas en charge l'héritage multiple et hybride. Nous avons discuté de l'ambiguïté d'héritage multiple et du problème Diamond en Java.
Ensuite, nous avons discuté des différentes règles à suivre lors de l'implémentation de l'héritage en Java. Avec cela, nous avons terminé notre discussion sur la relation IS-A en Java.
=> Regardez la série de formation Java simple ici.
lecture recommandée
- Qu'est-ce que l'héritage en Java - Tutoriel avec des exemples
- Héritage en C ++
- Types d'héritage en C ++
- Principes de base de Java: syntaxe Java, classe Java et principaux concepts Java
- Classe Java Integer et Java BigInteger avec exemples
- Types de classes en Java: abstrait, concret, final, statique
- Variables Java et leurs types avec des exemples
- Tutoriel de classe de scanner Java avec des exemples