Java Language
Super Keyword

Super-Keyword-Verwendung mit Beispielen

Super Keyword spielt an drei Stellen eine wichtige Rolle

1. Konstruktorebene
2. Methodenebene
3. Variable Ebene

Konstruktorebene

super Schlüsselwort wird verwendet, um den Konstruktor der übergeordneten Klasse aufzurufen. Dieser Konstruktor kann ein Standardkonstruktor oder ein parametrisierter Konstruktor sein.

• Standardkonstruktor: super();

• Parametrisierter Konstruktor: 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();
     }
   }
  

Hinweis : super() muss die erste Anweisung im Konstruktor sein, andernfalls wird die Kompilierungsfehlermeldung angezeigt.

Methodenebene

super Schlüsselwort kann auch bei Überschreiben von Methoden verwendet werden. super Schlüsselwort kann verwendet werden, um die übergeordnete Klassenmethode aufzurufen oder aufzurufen.

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

Hinweis: Wenn nicht Methode überschrieben , dann brauchen wir nicht verwenden super Schlüsselwort Elternklasse - Methode aufzurufen.

Variable Ebene

super wird verwendet, um auf die Instanzvariable der übergeordneten Klassenklasse zu verweisen. Im Falle der Vererbung kann die Basisklasse möglich sein, und die abgeleitete Klasse kann ähnliche Datenmitglieder haben. Um zwischen dem Datenmitglied der Basis- / Elternklasse und der abgeleiteten / Kindklasse zu unterscheiden, sind im Kontext der abgeleiteten Klasse die Basisklassendaten zu unterscheiden Mitgliedern muss ein super Schlüsselwort vorangestellt werden.

//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();    
    }
}

Anmerkung : Wenn wir kein super Schlüsselwort vor dem Namen des Basisklassendatenmitglieds schreiben, wird es als aktuelles Klassendatenmitglied bezeichnet, und das Basismitglied wird im Kontext der abgeleiteten Klasse ausgeblendet.