Super mot-clé en Java

Super est un mot-clé utilisé pour appeler une fonction ou une méthode dans la superclasse. Ceci sera défini à l’intérieur de la sous-classe. Les méthodes qui sont uniquement publiques et protégées peuvent être appelées à l'aide de ce mot-clé. En d’autres termes, les méthodes privées et les méthodes statiques ne peuvent pas être appelées à l’aide de cela. Le super mot-clé en Java peut également être utilisé pour appeler les constructeurs de la classe parent. La syntaxe, les exemples et plus de détails sur le super mot-clé seront abordés dans les sections suivantes.

Syntaxe

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

super.<<method-name>> or super([0 or more arguments]);

Comment fonctionne Super Keyword en Java ?

Comme déjà mentionné, super peut être utilisé à plusieurs reprises.

• Pour faire référence à une variable d'instance d'une classe parent immédiate.
• Pour faire référence à la méthode d'une classe parent immédiate.
• Pour faire référence au constructeur d'une classe parent immédiat.

1. Pour faire référence à une variable d'instance d'une classe parent immédiate

Si les classes parent et enfant ont les mêmes données membres, le mot-clé Super peut être utilisé pour accéder au champ ou aux données membres de la classe parent. Une ambiguïté pour la machine virtuelle Java peut survenir dans ce cas.

Exemple :

Code :

class A {
protected String name="ann";
}
class B extends A {
public String name="Anna";
public void hello() {
System.out.println("I am  " + name);
System.out.println("I am  " + super.name);
}
}

Ici, deux classes A et B, ont un nom de champ commun. Une fonction printType() à l'intérieur de la classe enfant utilise le mot-clé super pour faire référence au champ d'une classe parent.

2. Pour référer la méthode d'une classe de parent immédiat

Le remplacement de méthode est un processus par lequel une classe enfant déclare la même fonction ou méthode déjà disponible dans la classe parent. Supposons que si un appel à la méthode se produit à partir de l’objet de la classe enfant, alors seule la méthode de la classe enfant sera appelée. Afin d'accéder à la méthode parent, un super mot-clé peut être utilisé.

Exemple :

Code :

class A {
protected String name="ann";
public void hello() {
System.out.println("I am  " + name);
}
}
class B extends A {
public String name="Anna”;
public void hello() {
System.out.println("I am  " + name);
}
public void test()
{
hello();
super.hello();
}
}

Ici, deux classes, A et B, ont la même méthode hello(). A l'aide d'un super mot-clé dans la fonction test(), il est possible d'accéder à la méthode hello() d'une classe parent.

3. Pour référer le constructeur de la classe parent immédiate

On sait déjà qu'un constructeur (par défaut) est automatiquement appelé lors de la création de l'objet d'une classe. Le mot-clé super peut être utilisé pour appeler explicitement le constructeur de la superclasse à partir du constructeur de la sous-classe. Assurez-vous que super n'est utilisé qu'à l'intérieur du constructeur de la sous-classe, et qu'il s'agit de la première instruction à l'intérieur de celui-ci.

Exemple :

Code :

class A {
//constructor of parent class
A() {    System.out.println("I am Kavya Madhavan");
}
}
//child class
class B extends A {
//constructor of child class
B() {
super();
System.out.println("I am Dileep Menon");  } }

Exemples de Super Keyword en Java

Voici les différents exemples évoqués :

Exemple n°1

Dans le programme suivant, un nom de variable commun est présent et super est utilisé pour appeler la variable dans une classe parent.

Code :

//Java program to illustrate Super keyword to refer instance variable
//parent class
class A {
protected String name="ann";
}
//child classs
class B extends A {
public String name="Anna";//variable which is same in parent class
//sample method
public void hello() {
System.out.println("I am  " + name);
System.out.println("I am  " + super.name);
}
}
//main class
public class SuperExample {
public static void main(String[] args) {
B objb=new B();//object of child class
objb.hello();//call the method in child class
}
}

Sortie :

Exemple n°2

Ce programme aide à démontrer le super mot-clé tout en faisant référence à la même méthode dans une classe parent. Ici, hello() est une méthode disponible dans les deux classes.

Code :

//Java program to illustrate Super keyword to refer same method in parent class
//parent class
class A {
protected String name="ann";
public void hello() {
System.out.println("I am  " + name);
}
}
//child classs
class B extends A {
public String name="Anna";//variable which is same in parent class
//sample method which is same in parent class
public void hello() {
System.out.println("I am  " + name);
}
//method to call the hello() method in parent and child class
public void test()
{
hello();
super.hello();
}
}
//main class
public class SuperExample {
public static void main(String[] args) {
B objb=new B();//object of child class
objb.test();//call the method in child class
} }

Sortie :

Exemple #3

Ce programme appelle le constructeur de la classe parent à l'aide du mot-clé super.

Code :

//Java program to illustrate Super keyword to refer constructor in parent class
//parent class
class A {
//constructor of parent class
A() {
System.out.println("I am Kavya Madhavan");
}
}
//child class
class B extends A {
//constructor of child class
B() {
super();
System.out.println("I am Dileep Menon");
}
}
//main class
public class SuperExample {
public static void main(String[] args) {
B objb=new B();//object of child class
}
}

Sortie :

Exemple n°4

Ce programme démontre l'utilisation d'un super mot-clé pour faire référence au constructeur paramétré d'une classe parent.

Code :

//Java program to illustrate Super keyword to refer parameterised constructor in parent class
//parent class
class A {
//constructor of parent class
A() {
System.out.println("I am Kavya Madhavan");
}
//parameterised constructor
A(String name) {
System.out.println("I am " + name);
}
}
//child class
class B extends A {
//constructor of child class
B() {
super("Renuka");
System.out.println("I am Dileep Menon");
}
}
//main class
public class SuperExample {
public static void main(String[] args) {
B objb=new B();//object of child class
}
}

Sortie :

Conclusion

Super est un mot-clé en Java utilisé pour faire référence aux méthodes ou fonctions, aux variables d'instance ou aux attributs et aux constructeurs de la classe parent. Si aucun constructeur n'est déclaré, le compilateur crée automatiquement un constructeur par défaut. De même, le compilateur appelle automatiquement super() s'il n'est pas déclaré. Dans ce document, plusieurs aspects du super mot-clé sont expliqués en détail.

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!