super Schlüsselwort in Java

Das Schlüsselwort super wird in Java verwendet, um auf das unmittelbare übergeordnete Klassenobjekt zu verweisen. Sie wird häufig verwendet, um auf die Methoden und Konstruktoren der Elternklasse zuzugreifen, damit eine Unterklasse die Funktionalität ihrer Oberklasse erben und wiederverwenden kann.

Verwendung

Das Schlüsselwort super kann in drei Hauptkontexten verwendet werden:

1. Um den Konstruktor der Oberklasse aufzurufen.
2. Um auf eine Methode aus der Oberklasse zuzugreifen, die in der Unterklasse überschrieben wurde.
3. Um auf ein Feld aus der Oberklasse zuzugreifen, wenn es durch ein gleichnamiges Feld in der Unterklasse ausgeblendet wird.

Syntax

super();
super.methodName();
super.fieldName;

Beispiele

Beispiel 1: Aufruf des Superklassen-Konstruktors

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

In diesem Beispiel ruft der super() Aufruf im Dog Konstruktor den Konstruktor der Animal Klasse auf.

Beispiel 2: Zugriff auf Oberklassen-Methode

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

Hier ruft der Aufruf super.sound() in der Methode der Klasse Dog sound() die Methode sound() der Klasse Animal auf.

Beispiel 3: Zugriff auf das Feld der Oberklasse

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

In diesem Beispiel wird super.color verwendet, um auf das Feld color der Klasse Animal zuzugreifen, das durch das Feld color der Klasse Dog verdeckt wird.

Tipps und bewährte Praktiken

• Konstrukteursverkettung: Verwende super() im Konstruktor einer Unterklasse, um sicherzustellen, dass der Konstruktor der Oberklasse aufgerufen wird, damit das Objekt richtig initialisiert werden kann.  

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

• Method Overriding: Verwende super.methodName(), um eine Methode aus der Oberklasse aufzurufen, wenn sie in der Unterklasse überschrieben wird. Dies ist nützlich, um das Verhalten der geerbten Methode zu erweitern oder zu ändern.  

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

• Feldzugang: Verwende super.fieldName, um auf ein Feld der Oberklasse zuzugreifen, wenn es durch ein gleichnamiges Feld in der Unterklasse verborgen ist. Das hilft, Mehrdeutigkeiten zu vermeiden und stellt sicher, dass auf das richtige Feld zugegriffen wird.  

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

• Lesbarkeit: Verwende super mit Bedacht, um deinen Code lesbarer und wartbarer zu machen. Die übermäßige Verwendung von super kann dazu führen, dass der Code schwerer zu verstehen ist.
• Platzierung im Baugewerbe: Platziere den Aufruf super() immer als erste Anweisung im Konstruktor der Unterklasse, um Kompilierungsfehler zu vermeiden.
• Statische Kontexte: Denk daran, dass super nicht in statischen Methoden oder statischen Kontexten verwendet werden kann, da es sich auf eine Instanz einer Klasse bezieht.