Java super Keyword

Dans ce tutoriel, nous allons apprendre le mot-clé super en Java à l'aide d'exemples.

Le mot-clé super en Java est utilisé dans la classe fille pour accéder aux membres de la classe parente (attributs, constructeurs et méthodes).

Assurez-vous d'avoir comprisJava inheritance。

Utilisation du mot-clé super

1. 　Appel de la méthode redéfinie du parent dans la classe fille.
   

2. Si la classe parente (superclass) et la classe fille (subclass) ont des attributs de noms identiques, accédez aux attributs de la classe parente (champs).

3. Appel explicitement du constructeur sans paramètres ou du constructeur avec paramètres de la classe parente à partir du constructeur de la classe fille.

　 Laissez-nous comprendre toutes ces utilisations.

1.Accès à la méthode redéfinie de la classe parente

Si une méthode de même nom est définie dans la classe parente et la classe fille, la méthode de la classe fille couvre la méthode de la classe parente. Cela s'appelleMéthode redéfinie。

Exemple1Méthode redéfinie

class Animal {
　　//Méthode
　　public void display(){
　　　　System.out.println("Je suis un animal");
　　}
}
class Dog extends Animal {
　　//Méthode redéfinie
　　@Override
　　public void display(){
　　　　System.out.println("I am a dog");
　　}
　　public void printMessage(){
　　　　display();
　　}
}
class Main {
　　public static void main(String[] args) {
　　　　Dog dog1　= new Dog();
　　　　dog1.printMessage();
　　}
}

Output result

I am a dog

Dans cet exemple, en créant un objet de la classe Dog dog1Nous pouvons appeler sa méthode printMessage(), puis cette méthode exécute l'instruction display().

Comme display() est définie dans les deux classes, la méthode display() de la classe fille Dog surcharge la méthode display() de la classe parente Animal. Par conséquent, la méthode display() de la classe fille est appelée.

Que faire si vous devez appeler une méthode redéfinie de la classe parente ?

Si vous devez appeler la méthode redéfinie display() de la classe parente Animal, utilisez super.display().

Exemple2Appel de la méthode de la classe parente via super

class Animal {
　　//Méthode
　　public void display(){
　　　　System.out.println("Je suis un animal");
　　}
}
class Dog extends Animal {
　　//Méthode redéfinie
　　@Override
　　public void display(){
　　　　System.out.println("I am a dog");
　　}
　　public void printMessage(){
　　　　//Cela appelle la méthode redéfinie
　　　　display();
　　　　//　Cela appelle la méthode de la classe parente
　　　　super.display();
　　}
}
class Main {
　　public static void main(String[] args) {
　　　　Dog dog1　= new Dog();
　　　　dog1.printMessage();
　　}
}

Output result

I am a dog
Je suis un animal

Voici comment fonctionne le programme ci-dessus.

2.Accès aux attributs du parent (classe mère)

La classe parente et la classe fille peuvent avoir des attributs de noms identiques. Nous utilisons le mot-clé super pour accéder aux attributs de la classe parente.

Exemple3Accès aux attributs de la classe parente

class Animal {
　　protected String type="Animal";
}
class Dog extends Animal {
　　public String type="Mammifère";
　　public void printType() {
　　　　System.out.println("Je suis \""　+　type);
　　　　System.out.println("Je suis un \""　+　super.type);
　　}
}
class Main {
　　public static void main(String[] args) {
　　　　Dog dog1　= new Dog();
　　　　dog1.printType();
　　}
}

输出：

Je suis un mammifère
Je suis un animal

在这个实例中，我们在超类Animal和子类Dog中定义了相同的实例字段类型。
然后我们创建了Dog类的对象dog1。然后，使用此对象调用printType()方法。

在printType()函数内部，

• type　 - 指的是子类Dog的属性。

• super.type　 - 指超类Animal的属性。

因此，System.out.println("Je suis " + type);输出 "Je suis un mammifère"，并且，System.out.println("Je suis un " + super.type);打印输出"Je suis un animal"。

3.使用super()访问超类构造函数

众所周知，创建类的对象时，将自动调用其默认构造函数。

要从子类构造函数中显式调用超类构造函数，我们使用super()。这是super关键字的一种特殊形式。

注意：super() 只能在子类构造函数中使用，并且必须是第一条语句。

Exemple4：使用super()

class Animal {
　　//Animal类的默认或无参数构造函数
　　Animal() {
　　　　System.out.println("Je suis un animal");
　　}
}
class Dog extends Animal {
　　//　Dog类的默认或无参数构造函数
　　Dog() {
　　　　//调用超类的默认构造函数
　　　　super();
　　　　System.out.println("I am a dog");
　　}
}
class Main {
　　public static void main(String[] args) {
　　　　Dog dog1　= new Dog();
　　}
}

Output result

Je suis un animal
I am a dog

在这里，当Dog类的对象dog1被创建时，它会自动调用该类的默认或无参数构造函数。
在子类构造函数中，super()语句调用超类的构造函数并执行其中的语句。因此，我们得到的结果"Je suis un animal"。

然后，程序流返回到子类构造函数并执行其余语句。 因此，打印输出"Je suis un chien"。

但是，不是必须使用super()。 即使在子类构造函数中没有使用super()，编译器也会隐式调用超类的默认构造函数。

那么，如果编译器自动调用super()，为什么还要显式它，而使用冗余代码呢？

如果必须从子类构造函数中调用超类的参数化构造函数（带有参数的构造函数），则必须显式地使用它。

带参数的super()必须始终是子类的构造函数体中的第一个语句，否则，将出现编译错误。

Exemple5：使用super()调用参数化构造函数

class Animal {
　　//Constructeur par défaut ou sans paramètres
　　Animal() {
　　　　System.out.println("Je suis un animal");
　　}
　　//Constructeur paramétré
　　Animal(String type) {
　　　　System.out.println("Type: ")}+type);
　　}
}
class Dog extends Animal {
　　//Default constructor
　　Dog() {
　　　　//Call the parameterized constructor of the superclass
　　　　super("Animal");
　　　　System.out.println("I am a dog");
　　}
}
class Main {
　　public static void main(String[] args) {
　　　　Dog dog1　= new Dog();
　　}
}

Output result

Type: Animal
I am a dog

The compiler can automatically call the no-argument constructor. However, it cannot call the constructor with arguments.

If it is necessary to call the parameterized constructor, it must be explicitly defined in the subclass constructor, as shown in the statement above the code:

super("Animal");

Please note that in the above example, we used super("Animal") to explicitly call the parameterized constructor. In this case, the compiler will not call the default constructor of the superclass.