Java super-Schlüsselwort

In diesem Tutorial werden wir mit Beispielen lernen, wie man das Schlüsselwort "super" in Java verwendet.

Der Schlüsselwort "super" in Java wird in der untergeordneten Klasse verwendet, um auf die Mitglieder der übergeordneten Klasse (Attribute, Konstruktoren und Methoden) zuzugreifen.

Stellen Sie sicher, dass Sie bereits verstanden habenJava Vererbung.

Verwendung des Schlüsselworts "super"

1. 　Aufruf der überschriebenen Methode des übergeordneten Klassen in der untergeordneten Klasse.
   

2. Wenn die übergeordnete (superclass) und die untergeordnete Klasse (subclass) Attribute mit dem gleichen Namen haben, wird auf das Attribut (Feld) der übergeordneten Klasse zugegriffen.

3. Aufruf des konstruktionslosen oder parameterisierten Konstruktors der übergeordneten Klasse aus der Konstruktionsfunktion der untergeordneten Klasse.

　 Lassen Sie uns nun alle diese Anwendungen verstehen.

1.Zugriff auf überschriebene Methode der übergeordneten Klasse

Wenn in übergeordneter und untergeordneter Klasse Methoden mit dem gleichen Namen definiert sind, überschreibt die Methode in der untergeordneten Klasse die Methode in der übergeordneten Klasse. Dies wird: Methode überschreiben.

Beispiel1: Methode überschreiben

class Animal {
　　//Methode
　　public void display(){
　　　　System.out.println("Ich bin ein Tier");
　　}
}
class Dog extends Animal {
　　//Methode überschreiben
　　@Override
　　public void display(){
　　　　System.out.println("Ich bin ein Hund");
　　}
　　public void printMessage(){
　　　　display();
　　}
}
class Main {
　　public static void main(String[] args) {
　　　　Dog dog1　= new Dog();
　　　　Hund1.printMessage();
　　}
}

Ausgaberesultat

Ich bin ein Hund

In diesem Beispiel wird durch Erstellen eines Objekts der Klasse "Dog" namens "dog1, dann können wir ihre Methode "printMessage()" aufrufen, und diese Methode führt den Befehl "display()" aus.

Da "display()" in beiden Klassen definiert ist, überschreibt die Methode der Klasse "Dog" die Methode der Klasse "Animal". Daher wird "display()" der Klasse "Dog" aufgerufen.

Was ist, wenn man die überschriebene Methode der übergeordneten Klasse aufrufen muss?

Wenn der überschriebene Methode "display()" der Klasse "Animal" aufgerufen werden muss, dann verwenden Sie "super.display()".

Beispiel2: super ruft die Methode der übergeordneten Klasse auf

class Animal {
　　//Methode
　　public void display(){
　　　　System.out.println("Ich bin ein Tier");
　　}
}
class Dog extends Animal {
　　//Methode überschreiben
　　@Override
　　public void display(){
　　　　System.out.println("Ich bin ein Hund");
　　}
　　public void printMessage(){
　　　　//Das ruft die überschriebene Methode auf
　　　　display();
　　　　//　Das ruft die Methode der übergeordneten Klasse auf
　　　　super.display();
　　}
}
class Main {
　　public static void main(String[] args) {
　　　　Dog dog1　= new Dog();
　　　　Hund1.printMessage();
　　}
}

Ausgaberesultat

Ich bin ein Hund
Ich bin ein Tier

Hier ist, wie das obige Programm funktioniert.

2.Zugriff auf übergeordnete (Eltern-)Klasse Attribute

Übergeordnete und untergeordnete Klassen können Attribute mit dem gleichen Namen haben. Wir verwenden den Schlüsselwort "super", um auf die Attribute der übergeordneten Klasse zuzugreifen.

Beispiel3: Zugriff auf übergeordnete Klasse Attribute

class Animal {
　　protected String type="Lebewesen";
}
class Dog extends Animal {
　　public String type="Thier";
　　public void printType() {
　　　　System.out.println("Ich bin ", " " + " ");　+　type);
　　　　System.out.println("Ich bin ein ", " " + " ");　+　super.type);
　　}
}
class Main {
　　public static void main(String[] args) {
　　　　Dog dog1　= new Dog();
　　　　Hund1.printType();
　　}
}

Ausgabe:

Ich bin ein Säugetier
Ich bin ein Tier

In diesem Beispiel haben wir denselben Instanzfeldtyp in der Oberklasse Animal und der Unterklasse Dog definiert.
Dann haben wir das Objekt der Klasse Dog dog erstellt1.Dann wird mit diesem Objekt der Methodenaufruf printType() durchgeführt.

imprintType()-Funktion intern

• type　 - bezieht sich auf das Attribut der Unterklasse Dog.

• super.type　 - bezieht sich auf das Attribut der Oberklasse Animal.

Daher, System.out.println("Ich bin " + type);Ausgabe "Ich bin ein Säugetier"und, System.out.println("Ich bin ein " + super.type); AusgabeAusgabe "Ich bin ein Tier".

3.Verwenden Sie super() zum Zugriff auf den Konstruktor der Oberklasse

Wie bekannt, wird bei der Erstellung eines Objekts einer Klasse automatisch der Standardkonstruktor aufgerufen.

Um den Konstruktor der Oberklasse aus dem Konstruktor der Unterklasse explizit aufzurufen, verwenden wir super(). Dies ist eine spezielle Form des Schlüsselworts super.

Hinweis: super() kann nur im Konstruktor der Unterklasse verwendet werden und muss als erstes Statement sein.

Beispiel4: verwendet super()

class Animal {
　　//Standard- oder parameterloser Konstruktor der Klasse Animal
　　Animal() {
　　　　System.out.println("Ich bin ein Tier");
　　}
}
class Dog extends Animal {
　　//　Standard- oder parameterloser Konstruktor der Klasse Dog
　　Dog() {
　　　　//ruft den Standardkonstruktor der Oberklasse auf
　　　　super();
　　　　System.out.println("Ich bin ein Hund");
　　}
}
class Main {
　　public static void main(String[] args) {
　　　　Dog dog1　= new Dog();
　　}
}

Ausgaberesultat

Ich bin ein Tier
Ich bin ein Hund

hier, wenn das Objekt der Klasse Dog dog1wird erstellt, ruft es automatisch den Standard- oder parameterlosen Konstruktor der Klasse auf.
wird im Konstruktor der Unterklasse aufgerufen, ruft super() den Konstruktor der Oberklasse auf und führt die darin enthaltenen Anweisungen aus. Daher erhalten wir das Ergebnis"Ich bin ein Tier".

Dann kehrt der Programmablauf zurück zum Konstruktor der Unterklasse und führt die restlichen Anweisungen aus. Daher wird "Ich bin ein Hund" ausgegeben.

Allerdings ist es nicht erforderlich, super() zu verwenden. Selbst wenn super() im Konstruktor der Unterklasse nicht verwendet wird, ruft der Compiler implizit den Standardkonstruktor der Oberklasse auf.

Warum sollte man dann super() explizit verwenden und redundanten Code verwenden, wenn der Compiler automatisch super() aufruft?

Wenn es erforderlich ist, den Konstruktor der Oberklasse aus dem Konstruktor der Unterklasse aufzurufenParameterisierter Konstruktor (Konstruktor mit Parametern)dann muss er explizit verwendet werden.

mit Parameter versehener super()muss stets seindem Konstruktorkörper der Unterklassevonder erste Befehlsonst wird ein Kompilationsfehler auftreten.

Beispiel5verwendet super() zum Aufruf des parameterisierten Konstruktors

class Animal {
　　//Standard- oder parameterloser Konstruktor
　　Animal() {
　　　　System.out.println("Ich bin ein Tier");
　　}
　　//Parameterisierte Konstruktor
　　Animal(String type) {
　　　　System.out.println("Typ: ")}}+type);
　　}
}
class Dog extends Animal {
　　//Standardkonstruktor
　　Dog() {
　　　　//Aufruf des parameterisierten Konstruktors der Oberklasse
　　　　super("Animal");
　　　　System.out.println("Ich bin ein Hund");
　　}
}
class Main {
　　public static void main(String[] args) {
　　　　Dog dog1　= new Dog();
　　}
}

Ausgaberesultat

Typ: Animal
Ich bin ein Hund

Der Compiler kann den Standardkonstruktor automatisch aufrufen. Er kann jedoch keine mit Parametern versehenen Konstrukturen aufrufen.

Wenn der parameterisierte Konstruktor aufgerufen werden muss, muss er im Konstruktor der Unterklasse explizit definiert werden, wie im obigen Code gezeigt:

super("Animal");

Bitte beachten Sie, dass wir in den obigen Beispielen super("Animal") verwendet haben, um den parameterisierten Konstruktor explizit aufzurufen. In diesem Fall ruft der Compiler nicht den Standardkonstruktor der Oberklasse auf.