mot-clé super en Java

Le mot-clé super en Java est utilisé pour faire référence à l'objet parent immédiat de la classe. Il est généralement utilisé pour accéder aux méthodes et aux constructeurs de la classe mère, ce qui permet à une sous-classe d'hériter et de réutiliser les fonctionnalités de sa superclasse.

Utilisation

Le mot-clé super peut être utilisé dans trois contextes principaux :

1. Pour appeler le constructeur de la superclasse.
2. Pour accéder à une méthode de la superclasse qui a été surchargée dans la sous-classe.
3. Pour accéder à un champ de la superclasse lorsqu'il est caché par un champ du même nom dans la sous-classe.

Syntax

super();
super.methodName();
super.fieldName;Propulsé par

Exemples

Exemple 1 : Appel du constructeur de la superclasse

class Animal {
    Animal() {
        System.out.println("Animal constructor called");
    }
}

class Dog extends Animal {
    Dog() {
        super(); // Calls the constructor of Animal class
        System.out.println("Dog constructor called");
    }
}

public class TestSuper {
    public static void main(String[] args) {
        Dog d = new Dog(); // Output: Animal constructor called
                          //         Dog constructor called
    }
}Propulsé par

Dans cet exemple, l'appel à super() dans le constructeur de Dog invoque le constructeur de la classe Animal.

Exemple 2 : Accès à la méthode de la superclasse

class Animal {
    void sound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    void sound() {
        super.sound(); // Calls the sound() method of Animal class
        System.out.println("Dog barks");
    }
}

public class TestSuper {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.sound(); // Output: Animal makes a sound
                   //         Dog barks
    }
}Propulsé par

Ici, l'appel super.sound() dans la méthode sound() de la classe Dog invoque la méthode sound() de la classe Animal.

Exemple 3 : Accès au champ de la superclasse

class Animal {
    String color = "white";
}

class Dog extends Animal {
    String color = "black";

    void displayColor() {
        System.out.println("Dog color: " +// Prints the color of Dog class
        System.out.println("Animal color: " + super.// Prints the color of Animal class
    }
}

public class TestSuper {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.displayColor(); // Output: Dog color: black
                          //         Animal color: white
    }
}Propulsé par

Dans cet exemple, super.color est utilisé pour accéder au champ color de la classe Animal, qui est caché par le champ color de la classe Dog.

Conseils et bonnes pratiques

• Enchaînement de constructeurs: Utilisez super() dans le constructeur d'une sous-classe pour vous assurer que le constructeur de la superclasse est appelé, ce qui permet d'initialiser correctement l'objet.  

  class Parent {
      Parent() {
          System.out.println("Parent constructor");
      }
  }
  
  class Child extends Parent {
      Child() {
          super(); // Always the first statement in the constructor
          System.out.println("Child constructor");
      }
  }Propulsé par

• Surcharge de méthode: Utilisez super.methodName() pour appeler une méthode de la superclasse lorsqu'elle est surchargée dans la sous-classe. Ceci est utile pour étendre ou modifier le comportement de la méthode héritée.  

  class Parent {
      void display() {
          System.out.println("Parent display");
      }
  }
  
  class Child extends Parent {
      void display() {
          super.display(); // Calls Parent's display method
          System.out.println("Child display");
      }
  }Propulsé par

• Accès au terrain: Utilisez super.fieldName pour accéder à un champ de la superclasse lorsqu'il est masqué par un champ du même nom dans la sous-classe. Cela permet d'éviter toute ambiguïté et de s'assurer que l'on accède au bon champ.  

  class Parent {
      int number = 10;
  }
  
  class Child extends Parent {
      int number = 20;
  
      void showNumber() {
          System.out.println(super.number); // Accesses Parent's number
      }
  }Propulsé par

• Lisibilité: Utilisez judicieusement super pour rendre votre code plus lisible et plus facile à maintenir. L'utilisation excessive de super peut rendre le code plus difficile à comprendre.
• Placement dans les constructeurs: Pour éviter les erreurs de compilation, placez toujours l'appel à super() comme première instruction dans le constructeur de la sous-classe.
• Contextes statiques: N'oubliez pas que super ne peut pas être utilisé dans des méthodes statiques ou des contextes statiques, car il fait référence à une instance d'une classe.