Héritage est la fonctionnalité la plus puissante de la programmation orientée objet. Cela nous permet d'hériter des propriétés d'une classe dans une autre classe. Dans cette section, nous discuterons types d'héritage en Java en profondeur avec des exemples concrets. Nous créerons également des programmes Java pour implémenter le concept de différents types d'héritage.

création de liste en java

Héritage

Héritage est un mécanisme permettant de générer une nouvelle classe à partir d’une classe existante. La (ancienne) classe existante est connue sous le nom de classe de base ou super classe ou classe parent . La nouvelle classe est connue sous le nom de Classe dérivée ou sous-classe ou classe d'enfant . Cela nous permet d'utiliser les propriétés et le comportement d'une classe (parent) dans une autre classe (enfant).

Une classe dont les propriétés sont héritées est appelée classe parent et une classe qui hérite des propriétés de la classe parent est appelée classe d'enfant . Ainsi, il établit une relation entre la classe parent et enfant qui est connue sous le nom de parent-enfant ou Est un relation.

Supposons qu'il existe deux classes nommées Père et Enfant et nous voulons hériter des propriétés de la classe Father dans la classe Child. Nous pouvons y parvenir en utilisant le s'étend mot-clé.

 //inherits the properties of the Father class class Child extends Father { //functionality } 

Quand devrions-nous recourir à l’héritage ?

L'héritage fournit le réutilisabilité de code, surtout lorsqu'il y a une grande échelle de code à réutiliser. Il établit également la relation entre les différentes classes, connue sous le nom de Est un relation. Nous pouvons également l'utiliser si nous voulons atteindre remplacement de méthode .

Points à retenir

• Le constructeur ne peut pas être hérité en Java.
• Les membres privés ne sont pas hérités en Java.
• L'héritage cyclique n'est pas autorisé en Java.
• Attribuez une référence parent aux objets enfants.
• Les constructeurs sont exécutés en raison de super() présent dans le constructeur.

Types d'héritage

Java prend en charge les quatre types d'héritage suivants :

• Héritage unique
• Héritage à plusieurs niveaux
• Héritage hiérarchique
• Héritage hybride

Remarque : L'héritage multiple n'est pas pris en charge en Java.

Discutons de chacun avec un exemple approprié.

convertir la date en chaîne

Héritage unique

En héritage simple, une sous-classe est dérivée d’une seule super-classe. Il hérite des propriétés et du comportement d'une classe monoparentale. Parfois, on l'appelle aussi héritage simple .

Dans la figure ci-dessus, Employee est une classe parent et Executive est une classe enfant. La classe Executive hérite de toutes les propriétés de la classe Employee.

Implémentons le mécanisme d'héritage unique dans un programme Java.

Exécutif.java

 class Employee { float salary=34534*12; } public class Executive extends Employee { float bonus=3000*6; public static void main(String args[]) { Executive obj=new Executive(); System.out.println('Total salary credited: '+obj.salary); System.out.println('Bonus of six months: '+obj.bonus); } } 

Sortir:

 Total salary credited: 414408.0 Bonus of six months: 18000.0 

Héritage à plusieurs niveaux

Dans héritage à plusieurs niveaux , une classe est dérivée d'une classe qui est également dérivée d'une autre classe est appelée héritage multi-niveau. En termes simples, nous pouvons dire qu’une classe qui a plus d’une classe parent est appelée héritage multi-niveaux. Notez que les cours doivent être de niveaux différents. Par conséquent, il existe une seule classe de base et une seule classe dérivée, mais plusieurs classes de base intermédiaires.

Dans la figure ci-dessus, la classe Marks hérite des membres ou méthodes de la classe Students. La classe Sports hérite des membres de la classe Marks. Par conséquent, la classe Student est la classe parent de la classe Marks et la classe Marks est la classe parent de la classe Sports. Par conséquent, la classe Sports hérite implicitement des propriétés de Student avec la classe Marks.

Implémentons le mécanisme d'héritage multi-niveaux dans un programme Java.

MultilevelInheritanceExample.java

 //super class class Student { int reg_no; void getNo(int no) { reg_no=no; } void putNo() { System.out.println('registration number= '+reg_no); } } //intermediate sub class class Marks extends Student { float marks; void getMarks(float m) { marks=m; } void putMarks() { System.out.println('marks= '+marks); } } //derived class class Sports extends Marks { float score; void getScore(float scr) { score=scr; } void putScore() { System.out.println('score= '+score); } } public class MultilevelInheritanceExample { public static void main(String args[]) { Sports ob=new Sports(); ob.getNo(0987); ob.putNo(); ob.getMarks(78); ob.putMarks(); ob.getScore(68.7); ob.putScore(); } } 

Sortir:

suite d'outils à ressort

 registration number= 0987 marks= 78.0 score= 68.7 

Héritage hiérarchique

Si plusieurs classes sont dérivées d’une seule classe de base, cela s’appelle héritage hiérarchique .

Dans la figure ci-dessus, les classes Science, Commerce et Arts héritent d'une classe monoparentale nommée Student.

Implémentons le mécanisme d'héritage hiérarchique dans un programme Java.

HierarchicalInheritanceExample.java

 //parent class class Student { public void methodStudent() { System.out.println('The method of the class Student invoked.'); } } class Science extends Student { public void methodScience() { System.out.println('The method of the class Science invoked.'); } } class Commerce extends Student { public void methodCommerce() { System.out.println('The method of the class Commerce invoked.'); } } class Arts extends Student { public void methodArts() { System.out.println('The method of the class Arts invoked.'); } } public class HierarchicalInheritanceExample { public static void main(String args[]) { Science sci = new Science(); Commerce comm = new Commerce(); Arts art = new Arts(); //all the sub classes can access the method of super class sci.methodStudent(); comm.methodStudent(); art.methodStudent(); } } 

Sortir:

 The method of the class Student invoked. The method of the class Student invoked. The method of the class Student invoked. 

Héritage hybride

Les moyens hybrides sont constitués de plusieurs. L'héritage hybride est la combinaison de deux ou plusieurs types d'héritage.

Dans la figure ci-dessus, Grand-Père est une super classe. La classe Father hérite des propriétés de la classe GrandFather. Puisque Père et Grand-Père représentent un héritage unique. De plus, la classe Père est héritée par la classe Fils et Fille. Ainsi, le Père devient la classe parentale du Fils et de la Fille. Ces classes représentent l'héritage hiérarchique. Ensemble, cela dénote l’héritage hybride.

sinon si bash

Implémentons le mécanisme d'héritage hybride dans un programme Java.

Fille.java

 //parent class class GrandFather { public void show() { System.out.println('I am grandfather.'); } } //inherits GrandFather properties class Father extends GrandFather { public void show() { System.out.println('I am father.'); } } //inherits Father properties class Son extends Father { public void show() { System.out.println('I am son.'); } } //inherits Father properties public class Daughter extends Father { public void show() { System.out.println('I am a daughter.'); } public static void main(String args[]) { Daughter obj = new Daughter(); obj.show(); } } 

Sortir:

 I am daughter. 

Héritage multiple (non pris en charge)

Java ne prend pas en charge plusieurs héritages en raison d'ambiguïté. Par exemple, considérons le programme Java suivant.

chiffres alphabétiques

Démo.java

 class Wishes { void message() { System.out.println('Best of Luck!!'); } } class Birthday { void message() { System.out.println('Happy Birthday!!'); } } public class Demo extends Wishes, Birthday //considering a scenario { public static void main(String args[]) { Demo obj=new Demo(); //can't decide which classes' message() method will be invoked obj.message(); } } 

Le code ci-dessus génère une erreur car le compilateur ne peut pas décider quelle méthode message() doit être invoquée. Pour cette raison, Java ne prend pas en charge les héritages multiples au niveau de la classe mais peut être obtenu via un interface .