Java super
Java-Super
In diesem Tutorial lernen wir anhand von Beispielen das Schlüsselwort super in Java kennen.
Der super Das Schlüsselwort in Java wird in Unterklassen verwendet, um auf Oberklassenelemente (Attribute, Konstruktoren und Methoden) zuzugreifen.
Bevor wir etwas über super erfahren Schlüsselwort, stellen Sie sicher, dass Sie etwas über die Java-Vererbung wissen.
Verwendungen des Super-Keywords
- Zum Aufrufen von Methoden der Oberklasse, die in der Unterklasse überschrieben wird.
- Um auf Attribute (Felder) der Oberklasse zuzugreifen, wenn sowohl die Oberklasse als auch die Unterklasse Attribute mit demselben Namen haben.
- Zum expliziten Aufrufen des No-Arg der Superklasse (Standard) oder des parametrisierten Konstruktors aus dem Konstruktor der Unterklasse.
Lassen Sie uns jede dieser Verwendungen verstehen.
1. Greifen Sie auf überschriebene Methoden der Oberklasse zu
Wenn Methoden mit demselben Namen sowohl in der Oberklasse als auch in der Unterklasse definiert sind, überschreibt die Methode in der Unterklasse die Methode in der Oberklasse. Dies wird Methodenüberschreibung genannt.
Beispiel 1:Methodenüberschreibung
class Animal {
// overridden method
public void display(){
System.out.println("I am an animal");
}
}
class Dog extends Animal {
// overriding method
@Override
public void display(){
System.out.println("I am a dog");
}
public void printMessage(){
display();
}
}
class Main {
public static void main(String[] args) {
Dog dog1 = new Dog();
dog1.printMessage();
}
}
Ausgabe
I am a dog
In diesem Beispiel durch Erstellen eines Objekts dog1 von Hund Klasse, können wir ihre Methode printMessage() aufrufen der dann display() ausführt Aussage.
Seit display() In beiden Klassen ist die Methode der Unterklasse Dog definiert überschreibt die Methode der Oberklasse Animal . Daher die display() der Unterklasse aufgerufen wird.
Was ist, wenn die überschriebene Methode der Oberklasse aufgerufen werden muss?
Wir verwenden super.display() wenn die überschriebene Methode display() der Oberklasse Animal muss angerufen werden.
Beispiel 2:super zum Aufrufen der Superklassenmethode
class Animal {
// overridden method
public void display(){
System.out.println("I am an animal");
}
}
class Dog extends Animal {
// overriding method
@Override
public void display(){
System.out.println("I am a dog");
}
public void printMessage(){
// this calls overriding method
display();
// this calls overridden method
super.display();
}
}
class Main {
public static void main(String[] args) {
Dog dog1 = new Dog();
dog1.printMessage();
}
}
Ausgabe
I am a dog I am an animal
Hier, wie das obige Programm funktioniert.
2. Zugriffsattribute der Oberklasse
Oberklasse und Unterklasse können gleichnamige Attribute haben. Wir verwenden den super Schlüsselwort, um auf das Attribut der Oberklasse zuzugreifen.
Beispiel 3:Zugriff auf Oberklassenattribut
class Animal {
protected String type="animal";
}
class Dog extends Animal {
public String type="mammal";
public void printType() {
System.out.println("I am a " + type);
System.out.println("I am an " + super.type);
}
}
class Main {
public static void main(String[] args) {
Dog dog1 = new Dog();
dog1.printType();
}
}
Ausgabe :
I am a mammal I am an animal
In diesem Beispiel haben wir dasselbe Instanzfeld type definiert sowohl in der Oberklasse Animal und die Unterklasse Dog .
Dann haben wir ein Objekt dog1 erstellt des Hundes Klasse. Dann die printType() Methode wird mit diesem Objekt aufgerufen.
Innerhalb der printType() Funktion,
- tippen bezieht sich auf das Attribut der Unterklasse Dog .
- super.type bezieht sich auf das Attribut der Oberklasse Animal.
Daher System.out.println("I am a " + type); gibt
Ich bin ein Säugetier
aus . Und System.out.println("I am an " + super.type); druckt
Ich bin ein Tier
.
3. Verwendung von super(), um auf den Konstruktor der Superklasse zuzugreifen
Wie wir wissen, wird beim Erstellen eines Objekts einer Klasse automatisch dessen Standardkonstruktor aufgerufen.
Um den Konstruktor der Oberklasse explizit vom Konstruktor der Unterklasse aufzurufen, verwenden wir super() . Es ist eine Sonderform des super Schlüsselwort.
super() kann nur innerhalb des Unterklassenkonstruktors verwendet werden und muss die erste Anweisung sein.
Beispiel 4:Verwendung von super()
class Animal {
// default or no-arg constructor of class Animal
Animal() {
System.out.println("I am an animal");
}
}
class Dog extends Animal {
// default or no-arg constructor of class Dog
Dog() {
// calling default constructor of the superclass
super();
System.out.println("I am a dog");
}
}
class Main {
public static void main(String[] args) {
Dog dog1 = new Dog();
}
}
Ausgabe
I am an animal I am a dog
Hier, wenn ein Objekt dog1 von Hund Klasse erstellt wird, ruft sie automatisch den Standard- oder No-Arg-Konstruktor dieser Klasse auf.
Innerhalb des Unterklassenkonstruktors, dem super() Anweisung ruft den Konstruktor der Oberklasse auf und führt die darin enthaltenen Anweisungen aus. Daher erhalten wir die Ausgabe
I am an animal
.
Der Ablauf des Programms kehrt dann zum Unterklassenkonstruktor zurück und führt die verbleibenden Anweisungen aus. Also Ich bin ein Hund wird gedruckt.
Verwenden Sie jedoch super() ist nicht zwingend. Auch wenn super() im Unterklassenkonstruktor nicht verwendet wird, ruft der Compiler implizit den Standardkonstruktor der Oberklasse auf.
Warum also redundanten Code verwenden, wenn der Compiler automatisch super() aufruft?
Es ist erforderlich, wenn der parametrisierte Konstruktor (ein Konstruktor, der Argumente akzeptiert) der Oberklasse muss vom Unterklassenkonstruktor aufgerufen werden.
Der parametrisierte super() muss immer die erste Anweisung im Körper des Konstruktors der Unterklasse sein, sonst erhalten wir einen Kompilierungsfehler.
Beispiel 5:Aufruf eines parametrisierten Konstruktors mit super()
class Animal {
// default or no-arg constructor
Animal() {
System.out.println("I am an animal");
}
// parameterized constructor
Animal(String type) {
System.out.println("Type: "+type);
}
}
class Dog extends Animal {
// default constructor
Dog() {
// calling parameterized constructor of the superclass
super("Animal");
System.out.println("I am a dog");
}
}
class Main {
public static void main(String[] args) {
Dog dog1 = new Dog();
}
}
Ausgabe
Type: Animal I am a dog
Der Compiler kann den No-Arg-Konstruktor automatisch aufrufen. Es kann jedoch keine parametrisierten Konstruktoren aufrufen.
Wenn ein parametrisierter Konstruktor aufgerufen werden muss, müssen wir ihn explizit im Konstruktor der Unterklasse definieren.
Beachten Sie, dass wir im obigen Beispiel explizit den parametrisierten Konstruktor super("Animal") aufgerufen haben . Der Compiler ruft in diesem Fall nicht den Standardkonstruktor der Oberklasse auf.
Java