Java Language
super mot clé

Super mot-clé avec des exemples

super mot-clé joue un rôle important dans trois endroits

1. Niveau constructeur
2. Niveau de méthode
3. Niveau variable

Niveau constructeur

super mot clé super est utilisé pour appeler le constructeur de la classe parent. Ce constructeur peut être constructeur par défaut ou constructeur paramétré.

• Constructeur par défaut: super();

• Constructeur paramétré: super(int no, double amount, String name);

   class Parentclass
   {
      Parentclass(){
         System.out.println("Constructor of Superclass");
      }
   }
   class Subclass extends Parentclass
   {
      Subclass(){
       /* Compile adds super() here at the first line
        * of this constructor implicitly
        */
       System.out.println("Constructor of Subclass");
      }
      Subclass(int n1){
       /* Compile adds super() here at the first line
        * of this constructor implicitly
        */
       System.out.println("Constructor with arg");
      }
      void display(){
       System.out.println("Hello");
      }
      public static void main(String args[]){
       // Creating object using default constructor
       Subclass obj= new Subclass();
       //Calling sub class method 
          obj.display();
          //Creating object 2 using arg constructor
          Subclass obj2= new Subclass(10);
          obj2.display();
     }
   }
  

Note : super() doit être la première instruction du constructeur sinon nous obtiendrons le message d'erreur de compilation.

Niveau de méthode

super mot super clé peut également être utilisé en cas de substitution de méthode. super mot clé super peut être utilisé pour appeler ou appeler la méthode de la classe parente.

class Parentclass
{
   //Overridden method
   void display(){
    System.out.println("Parent class method");
   }
}
class Subclass extends Parentclass
{
   //Overriding method
   void display(){
    System.out.println("Child class method");
   }
   void printMsg(){
    //This would call Overriding method
    display();
    //This would call Overridden method
    super.display();
   }
   public static void main(String args[]){        
    Subclass obj= new Subclass();
    obj.printMsg(); 
   }
}

Remarque : S'il n'y a pas de substitution de méthode, il n'est pas nécessaire d'utiliser le mot super clé super pour appeler la méthode de la classe parente.

Niveau variable

super est utilisé pour désigner la variable d'instance de la classe parente immédiate. En cas d'héritage, la classe de base et la classe dérivée peuvent avoir des membres de données similaires. Afin de différencier le membre de données de la classe de base / parent et de la classe dérivée / enfant, dans le contexte de la classe dérivée les membres doivent être précédés du mot super clé super .

//Parent class or Superclass
class Parentclass
{
    int num=100;
}
//Child class or subclass
class Subclass extends Parentclass
{
    /* I am declaring the same variable 
     * num in child class too.
     */
    int num=110;
    void printNumber(){
     System.out.println(num); //It will print value 110
     System.out.println(super.num); //It will print value 100
    }
    public static void main(String args[]){
       Subclass obj= new Subclass();
       obj.printNumber();    
    }
}

Remarque : Si vous n'écrivez pas de mot super clé super avant le nom du membre de données de la classe de base, il sera alors appelé membre de données de classe en cours et le membre de données de classe de base est masqué dans le contexte de la classe dérivée.