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;

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
    }
}

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
    }
}

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
    }
}

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");
      }
  }

• 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");
      }
  }

• 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
      }
  }

• 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.