Super mot-clé en java

Le mot-clé Super est utilisé dans l'héritage des classes Java. En Java, la superclasse est la classe parentale d'une classe actuelle. La classe actuelle est la classe infantile (sous-classe) de la superclasse. Il y a la possibilité que les classes de petit-enfant et de l'arrière-petits-enfants descendaient. La classe parent est la superclasse directe de la classe actuelle. La classe des grands-parents n'est pas la superclasse directe de la classe actuelle. Cet article explique l'utilisation du mot-clé, super en java. Il commence par présenter une classe de parents, un enfant de la classe parentale et un petit-enfant de la classe parentale. Ensuite, il montre comment le mot, super, s'intègre dans la hiérarchie. La hiérarchie ci-dessous forme une forme de la calculatrice.

Contenu de l'article

• Rappel de l'héritage Java
• Utilisation du mot-clé Super
• Conclusion

Rappel de l'héritage Java

Considérez la classe suivante:

classe CParent
int a;
int b;
int add ()
retourner a + b;

Cette classe a deux propriétés: A et B. En Java, les propriétés sont appelées champs. Cette classe a une méthode qui ajoute deux nombres, qui sont les valeurs de champ. Le nom de la classe est carent, avec le C précédent, pour la calculatrice. Le segment de code suivant dans la méthode principale (), sorties 5:

Parent CParent = new CParent ();
parent.a = 2;
parent.b = 3;
int radd = parent.ajouter();
Système.dehors.println (radd);

Considérez la classe suivante, qui est la sous-classe de la classe ci-dessus (CParent):

La classe CChild étend Carent
INT C;
int multiply ()
retourner a * c;

Remarque l'utilisation du mot-clé s'étend. Cette classe a le champ, C, et la méthode, multiply (). La classe hérite des champs, «a» et b, et la méthode, add (). Cependant, si la valeur du champ pour «A» ou B doit être utilisée pour cet objet instancié actuel (objet enfant), il doit encore être réaffecté une valeur. Pour cette classe, la valeur de «A» héritée est multipliée par la valeur de champ de la classe de C. Le nom de cette classe est Cchild, avec le C précédent, pour la calculatrice. Le segment de code suivant dans la méthode principale () convient à cette classe:

Cchild Child = new Cchild ();
enfant.a = 2;
enfant.c = 4;
int rmult = enfant.multiplier();
Système.dehors.println (rmult);

La sortie est 8. Notez que, bien que le champ «A» ait été hérité, il devait encore être réaffecté une valeur; Dans ce cas, la même valeur.

Considérez la classe suivante, qui est la sous-classe de la classe ci-dessus, Cchild:

La classe Cgrandchild étend Cchild
int d;
int divide ()
retourner a / d;

Remarque l'utilisation du mot-clé s'étend. Cette classe a le champ, D, et la méthode, divide (). La classe hérite des membres, «a», b et add () de la classe Cchild, qui les a hérités de la classe carent. Il hérite également des membres, C et Multiply () de la classe Cchild. Cependant, si la valeur du champ pour «A» ou B ou C, à partir des classes de parents ou de grands-parents, doit être utilisée pour cet objet instancié actuel (objet petit-enfant), il doit encore être réaffecté une valeur. Pour cette classe, la valeur de «A» héritée est divisée par la valeur de champ de la classe de D. Le nom de cette classe est Cgrandchild, avec le C précédent, pour la calculatrice. Le segment de code suivant dans la méthode principale () convient à cette classe:

Cgrandchild gchild = new Cgrandchild ();
gcild.a = 2;
gcild.d = 2;
int rdiv = gchild.diviser();
Système.dehors.println (rdiv);

La sortie est 1. Notez que, bien que le champ «A» ait été hérité, il devait encore être réaffecté une valeur; Dans ce cas, la même valeur, 2.

Utilisation du mot-clé Super

Champ et super
Dans le programme ci-dessus, la valeur du champ, «A» a été définie trois fois, une fois pour l'objet parent, une fois pour l'objet enfant, et une fois pour l'objet petit-enfant. Pour éviter cette réinitialisation à chaque fois, la valeur de 2 peut être attribuée une fois, dans l'implémentation de la classe parent (définition) comme suit:

classe CParent
int a = 2;
int b;
int add ()
retourner a + b;

Cela résout le problème de la réinitialisation pour chaque objet descendant. Dans les classes descendantes, le domaine, «A», est simplement mentionné (normalement).

Pour accéder à la valeur d'un champ hérité, le mot-clé Super doit être utilisé dans la mise en œuvre de la classe descendant de l'intérêt, comme suit:

super.nom de domaine

Le segment de code suivant montre comment le nom «A» a été accessible, dans une nouvelle implémentation CChild:

La classe CChild étend Carent
int p = super.un;
INT C;
int multiply ()
retour p * c;

La classe, Cchild, a maintenant son propre nom, P au lieu de «A». Et donc l'instruction dans la méthode Add (),

retourner a * c;

est maintenant,

retour p * c;

De la même manière, la mise en œuvre de la classe, Cgrandchild peut avoir «un» remplacé par Q, comme suit:

La classe Cgrandchild étend Cchild
int q = super.un;
int d;
int divide ()
retour q / d;

Remarque: l'héritage se déroule dans toutes les classes descendantes. Le champ «A» et la méthode Add () sont hérités dans la classe Cchild et dans la classe Cgrandchild.

Méthode et super
De même, un champ héréditaire est accessible dans la mise en œuvre d'une classe descendant; Une méthode héritée est également accessible dans une classe descendante, en utilisant le mot-clé Super. La syntaxe est:

super.MethodName ()

La mise en œuvre de la classe CChild d'origine peut être modifiée comme suit:

La classe CChild étend Carent
INT C;
int sum = super.ajouter();
int multiply ()
retourner a * c;

Notez que l'utilisation de Super. La méthode Add () héritée est désormais considérée comme une «somme» dans la mise en œuvre de CChild. Le champ C, et la méthode, multiply (), sont toujours là. Un segment de code pour l'ajout dans la méthode principale () qui convient à cette classe CChild modifiée est:

Cchild Child = new Cchild ();
int rsum = enfant.somme;
Système.dehors.println (rsum);

La sortie est de 5, en supposant que la classe parent a été modifiée avec:

int a = 2;
int b = 3;

Constructeur et super
Le constructeur par défaut, qui n'est pas implémenté, est hérité dans chaque classe descendant et n'a pas à être pris en compte dans l'implémentation des descendants et dans la méthode principale (). Cependant, une fois qu'une classe parent a un constructeur personnalisé, le reste de ses descendants doit avoir un constructeur similaire. Considérez la classe parent, avec un constructeur personnalisé, comme suit:

classe CParent
int a, b;
CAPERENT PUBLIC (int x, int y)
a = x; b = y;

int add ()
retourner a + b;

Les champs de «A» et B sont déclarés sans affectation. Le constructeur fait l'affectation. La classe d'enfants doit avoir le même constructeur ou un constructeur similaire. La classe enfant correspondante pour la hiérarchie de calculatrice d'origine peut être:

La classe CChild étend Carent
Cchild (int x, int y)
super (x, y);

INT C;
int multiply ()
retourner a * c;

Le constructeur ici est le même que celui du parent. Le corps du constructeur ici a juste:

super (x, y);

qui appelle simplement le constructeur du parent, avec les arguments reçus. «Super» représente ici le constructeur de classe parent. Ceci est une autre utilisation de Super. Il n'y a aucune modification dans cet enfant constructeur. La classe de petits-enfants correspondante pour la hiérarchie de calculatrice d'origine peut être:

La classe Cgrandchild étend Cchild
int d;
Cgrandchild (int x, int y, int z)
super (x, y);
d = z;

int divide ()
retourner a / d;

Le constructeur ici est modifié. Il a les mêmes paramètres x et y et un paramètre supplémentaire, z. z doit attribuer la valeur pour d, le diviseur. Le corps du constructeur commence par appeler le constructeur de la classe parentale. Ensuite, le champ du diviseur est affecté. Le segment de code suivant dans la méthode principale () convient à cette classe:

Cgrandchild gchild = nouveau cgrandchild (2, 3, 2);
int rdiv = gchild.diviser();
Système.dehors.println (rdiv);

La sortie pour cela est 1.

Conclusion

Super cherchera quelque chose dans la classe des parents immédiats. S'il ne le voit pas là, il le cherchera dans la classe des grands-parents. S'il ne le voit pas là-bas, il le cherchera dans la classe des arrière-grands-parents; Et ainsi de suite, jusqu'à ce qu'il le voit ou qu'il ne le voit pas. «Super» est généralement utilisé dans la mise en œuvre d'une sous-classe. Il est utilisé pour le champ, la méthode et le constructeur. La superclasse directe est la classe parentale. La classe des grands-parents est une superclasse, mais pas la superclasse directe. Ensuite, le lecteur doit comprendre l'utilisation de «Super» avec des classes imbriquées - voir plus tard.