Types d'héritage en Java | Expliqué

L'un des concepts clés de la programmation Java orientée objet est Héritage qui permet à une classe d'acquérir les attributs de classe et les fonctions membres des autres classes à l'aide d'un mot-clé prolongement. En Java, il existe plusieurs types d'héritage tels que les célibataires, à plusieurs niveaux et hiérarchiques qui peuvent être utilisés sur la base de différentes circonstances. Contrairement à certains autres langages de programmation comme C ++, Java ne prend pas en charge le concept d'héritage multiple pour éviter l'ambiguïté.

Cette rédaction fournit un aperçu détaillé des concepts suivants concernant les types d'héritage en Java:

• Héritage unique en Java
• Héritage hiérarchique en Java
• Héritage à plusieurs niveaux en Java
• Syntaxe de base de l'héritage unique, à plusieurs niveaux et hiérarchique en Java
• Comment utiliser l'héritage unique, à plusieurs niveaux et hiérarchique en Java

Alors, commençons!

Héritage unique

Dans le cas de l'héritage unique, il n'existe qu'une seule classe de parents et une classe d'enfants et la classe d'enfants peut accéder aux attributs et fonctions de la classe de la classe parentale. Nous devons prendre soin des attributs de classe et des méthodes de classe afin qu'il ne devrait pas y avoir de conflit entre les membres de la classe des parents et des enfants.

Syntaxe

La syntaxe de base de l'héritage unique sera comme ceci:

classe publique parent
// Attributs de classe
// Fonctions membres

classe publique Child étend le parent
// Attributs de classe
// Fonctions membres

Le prolongement le mot-clé indique que les propriétés de Classe parentale sont hérités du Classe d'enfants.

La figure ci-dessous fournira une meilleure compréhension de l'héritage unique:

Il n'y a que deux classes:

Classe d'enfants: il peut hériter de tous les attributs et méthodes du Classe parentale Et il n'a pas de sous-classe.

Classe parentale: c'est une superclasse héritée par Classe d'enfants.

Exemple

Dans l'extrait de code ci-dessous, nous créons trois classes: A Personne classe étendue par Étudiant classe et un «Javainheritance«Classe où nous créons le principal méthode:

classe de classe
Personnage int protégé = 25;
String protégé PersonName = "John";
public void affiche ()
Système.dehors.println ("This is Person Class");


Élève de classe étend la personne
protégé int rollno = 13;

classe publique javainheritance
public static void main (String [] args)
Étudiant std = nouveau étudiant ();
MST.afficher();
Système.dehors.println ("Student Roll Non. = "+ std.rollno);
Système.dehors.println ("Student name =" + std.nom d'une personne);
Système.dehors.println ("Student Age =" + Std.personnage);

La figure divisée ci-dessous montre le code complet avec sa sortie:

Dans la figure ci-dessus, une méthode de classe de personne est appelée avec l'objet de la classe étudiante et la sortie montre qu'il fonctionne correctement.

Héritage hiérarchique

Plusieurs classes peuvent être étendues à partir d'une classe en héritage hiérarchique I.e. Un parent peut avoir plusieurs classes enfants.

La syntaxe de base de l'héritage hiérarchique est montrée dans l'extrait de divagation ci-dessous

classe publique parent
// Attributs de classe
// Fonctions membres

classe publique Child1 étend le parent
// Attributs de classe
// Fonctions membres

classe publique Child2 étend le parent
// Attributs de classe
// Fonctions membres

L'extrait ci-dessus montre que les deux classes dérivées I.e. Enfant1 et Enfant2 peut hériter des propriétés du Parent classe.

La figure dirigée ci-dessous montre le flux de l'héritage hiérarchique:

Exemple

classe de classe
String protégé PersonName = "John";

Élève de classe étend la personne
protégé int rollno = 13;

L'employé de classe étend la personne
protégé int empid = 2;

classe publique javainheritance
public static void main (String [] args)
Étudiant std = nouveau étudiant ();
Système.dehors.println ("Student Roll Non. = "+ std.rollno);
Système.dehors.println ("Student name =" + std.nom d'une personne);
Employé EMP = nouvel employé ();
Système.dehors.println ("employee id =" + emp.empide);
Système.dehors.println ("Employee name =" + emp.nom d'une personne);

De l'extrait ci-dessus, nous pouvons observer que les deux Employé et Étudiant Les cours sont hérités par le Personne Classe. Donc, d'abord, nous devons créer les objets des deux classes individuellement, puis leurs attributs respectifs sont accessibles via leurs objets.

Le code complet et la sortie résultante sont illustrés dans la figure suivante:

La capture d'écran ci-dessus montre que les deux classes ont accédé aux attributs du Personne classe qui authentifie le fonctionnement de l'héritage hiérarchique.

Héritage à plusieurs niveaux

Dans l'héritage à plusieurs niveaux, l'héritage est effectué sur la base de niveau, je.e. Une classe peut hériter des propriétés d'une autre classe qui est déjà héritée d'une autre classe.

Syntaxe

La syntaxe de base de l'hérédité à plusieurs niveaux est indiquée dans l'extrait de divagation ci-dessous:

classe publique parent
// Attributs de classe
// Fonctions membres

classe publique Child1 étend le parent
// Attributs de classe
// Fonctions membres

classe publique Child2 étend Child1
// Attributs de classe
// Fonctions membres

La figure ci-dessous fournira une compréhension profonde de l'héritage à plusieurs niveaux:

Dans la figure ci-dessus, le Enfant1 La classe est une classe dérivée du Parent Classe et Enfant2 La classe est la classe dérivée de Enfant1. Donc, nous pouvons dire que le Enfant2 La classe est un petit-enfant du Parent classe. De cette façon, l'héritage à plusieurs niveaux fonctionne à Java.

Exemple

Cet exemple crée quatre classes: le premier est «Personne"La deuxième classe est"Étudiant"Classe qui hérite du"Personne"La classe et la troisième est"Département"Classe qui hérite du"Étudiant" classe. La quatrième classe est «Javainheritance» qui contient la méthode principale:

classe de classe
Personnage int protégé = 25;
String protégé PersonName = "John";
public void affiche ()
Système.dehors.println ("This is Person Class");


Élève de classe étend la personne
protégé int rollno = 13;

Le département de classe étend l'élève
String protégée Dept = "Computer Science";

classe publique javainheritance
public static void main (String [] args)
Département Dep = nouveau département ();
dep.afficher();
Système.dehors.println ("Student Roll Non. = "+ DEP.rollno);
Système.dehors.println ("Student Name =" + DEP.nom d'une personne);
Système.dehors.println ("Student Age =" + DEP.personnage);
Système.dehors.println ("Student Department =" + DEP.département);

Dans l'extrait ci-dessus, nous pouvons observer qu'une sous-classe Étudiant de classe Personne a une classe d'enfants Département qui garantit que c'est un exemple d'hérédité à plusieurs niveaux. La figure divisée ci-dessous fournit le code complet et la sortie respective de l'héritage à plusieurs niveaux:

La sortie ci-dessus authentifie que le Département La classe peut accéder aux attributs de Personne Classe à travers Étudiant classe. Qui valide le fonctionnement de l'héritage à plusieurs niveaux.

Conclusion

Java fournit différents types d'héritage qui peuvent être utilisés à différentes fins en fonction des différents scénarios et des besoins de l'utilisateur par exemple, en héritage unique, une seule classe est étendue de la superclasse. Dans l'héritage hiérarchique, une superclasse peut avoir plusieurs sous-classes. Tandis que, dans l'héritage à plusieurs niveaux, une sous-classe d'une classe de parents peut également avoir une classe d'enfants. Cet article présente un aperçu approfondi des types d'héritage, et il présente une compréhension profonde de l'héritage unique, à plusieurs niveaux et hiérarchique, leur syntaxe et comment les implémenter en Java.