super () in Java

222

Wird super()verwendet, um den übergeordneten Konstruktor aufzurufen? Bitte erklären Sie super().

Mohan
quelle
1
Muss genauer sein oder einfach die Dokumentation lesen ...
Manu
Überprüfen Sie im Zusammenhang mit dem Aufruf von super () auch diese Antwort. stackoverflow.com/questions/34349164/…
Vishrant
Hier erklärt: Java: Aufruf von super ()
aioobe

Antworten:

267

super() Ruft den übergeordneten Konstruktor ohne Argumente auf.

Es kann auch mit Argumenten verwendet werden. Dh super(argument1)und es wird der Konstruktor aufgerufen, der 1 Parameter vom Typ argument1(falls vorhanden) akzeptiert .

Es kann auch verwendet werden, um Methoden vom übergeordneten Element aufzurufen. Dhsuper.aMethod()

Weitere Infos und Tutorial hier

pakore
quelle
9
HINWEIS: Im ersten Fall muss für die übergeordnete Klasse ein Konstruktor ohne Argumente fehlschlagen, der einen Kompilierungsfehler auslöst.
KNU
Nit: Die Eltern / Kind-Terminologie ist für Klassenhierarchien nicht sehr gut. (Ein Kind ist kein Vater.)
Aioobe
Gibt es irgendwelche Einschränkungen, wo Super verwendet werden kann?
Aaron Franke
2
@VivekChavda, sicher , ein Kind kann ein Elternteil sein, wie nur ein Student ein Lehrer sein kann, etc. Aber ich denke , Sie verstehen den Unterschied im Vergleich zu Tier -> Hund zum Beispiel. Ein Hund ist notwendigerweise ein Tier. Eltern / Kind ist in der Regel ein eine hat Beziehung ( „A Elternteil hat ein Kind“) , während ein Tier / Hund ist eine „ist eine“ Beziehung. Siehe aioo.be/2016/06/29/a-child-is-not-always-a-parent.html
aioobe
2
@ AaronFranke, "Gibt es Einschränkungen, wo Super verwendet werden kann?" - Ja, super(...)darf nur als erste Anweisung in einem Konstruktor verwendet werden.
Aioobe
154

Einige Fakten:

  1. super() wird verwendet, um den unmittelbaren Elternteil anzurufen.
  2. super() kann mit Instanzmitgliedern verwendet werden, dh mit Instanzvariablen und Instanzmethoden.
  3. super() kann innerhalb eines Konstruktors verwendet werden, um den Konstruktor der übergeordneten Klasse aufzurufen.

OK, jetzt lassen Sie uns diese Punkte von praktisch umsetzen super().

Überprüfen Sie den Unterschied zwischen Programm 1 und 2. Hier belegt Programm 2 unsere erste Aussage super()in Java.

Programm 1

class Base
{
    int a = 100;
}

class Sup1 extends Base
{
    int a = 200;
    void Show()
    {
        System.out.println(a);
        System.out.println(a);
    }
    public static void main(String[] args)
    {
        new Sup1().Show();
    }
}

Ausgabe:

200
200

Schauen Sie sich nun Programm 2 an und versuchen Sie, den Hauptunterschied herauszufinden.

Programm 2

class Base
{
    int a = 100;
}

class Sup2 extends Base
{
    int a = 200;
    void Show()
    {
        System.out.println(super.a);
        System.out.println(a);
    }
    public static void main(String[] args)
    {
        new Sup2().Show();
    }
}

Ausgabe:

100
200

In Programm 1 war die Ausgabe nur von der abgeleiteten Klasse. Die Variable weder der Basisklasse noch der übergeordneten Klasse konnte gedruckt werden. In Programm 2 haben wir jedoch beim Drucken der Ausgabe eine super()Variable averwendet, und anstatt den Wert der Variablen ader abgeleiteten Klasse zu drucken, wurde der Wert der Variablen ader Basisklasse gedruckt . Es zeigt also, dass super()damit der unmittelbare Elternteil angerufen wird.

OK, überprüfen Sie jetzt den Unterschied zwischen Programm 3 und Programm 4.

Programm 3

class Base
{
    int a = 100;
    void Show()
    {
        System.out.println(a);
    }
}

class Sup3 extends Base
{
    int a = 200;
    void Show()
    {
        System.out.println(a);
    }
    public static void Main(String[] args)
    {
        new Sup3().Show();
    }
}

Ausgabe:

200

Hier ist die Ausgabe 200. Beim Aufruf Show()wurde die Show()Funktion der abgeleiteten Klasse aufgerufen. Aber was sollen wir tun, wenn wir die Show()Funktion der Elternklasse aufrufen wollen ? Überprüfen Sie Programm 4 für die Lösung.

Programm 4

class Base
{
    int a = 100;
    void Show()
    {
        System.out.println(a);
    }
}

class Sup4 extends Base
{
    int a = 200;
    void Show()
    {
        super.Show();
        System.out.println(a);
    }
    public static void Main(String[] args)
    {
        new Sup4().Show();
    }
}

Ausgabe:

100
200

Hier erhalten wir zwei Ausgaben, 100 und 200. Wenn die Show()Funktion der abgeleiteten Klasse aufgerufen wird, ruft sie zuerst die Show()Funktion der übergeordneten Klasse auf, da Show()wir innerhalb der Funktion der abgeleiteten Klasse die Show()Funktion der übergeordneten Klasse durch Putten aufgerufen haben das superSchlüsselwort vor dem Funktionsnamen.

SimonGates
quelle
4
Warum haben Sie Ihre Quellcode-Beispiele nicht eingerückt? Gibt es einen bestimmten Grund?
Erikbwork
NEIN erikb, ich möchte die Verwendung von super () wissen. Danach werde ich nur noch
Mohan
In meiner Basisklasse überlade ich den Konstruktor mit einem, zwei, ... Argumenten
Mohan
aber in meiner abgeleiteten Klasse benutze ich super () ohne Argu. Was passiert dann, wenn automatisch ein Standardkonstruktor einer Basisklasse aufgerufen wird
Mohan
2
super()ist kein Schlüsselwort. Es ist ein Konstruktoraufruf. superist ein Schlüsselwort, und # 1 und # 2 sind nur mit dieser Definition sinnvoll.
Marquis von Lorne
37

Quellartikel: Java: Aufruf von super ()


Ja. super(...)ruft den Konstruktor der Superklasse auf.

Illustration:

Geben Sie hier die Bildbeschreibung ein


Eigenständiges Beispiel:

class Animal {
    public Animal(String arg) {
        System.out.println("Constructing an animal: " + arg);
    }
}

class Dog extends Animal {
    public Dog() {
        super("From Dog constructor");
        System.out.println("Constructing a dog.");
    }
}

public class Test {
    public static void main(String[] a) {
        new Dog();
    }
}

Drucke:

Constructing an animal: From Dog constructor
Constructing a dog.
aioobe
quelle
In meiner Basisklasse überlade ich den Konstruktor mit einem, zwei, ... Argumenten in meiner abgeleiteten Klasse. Ich benutze super () ohne Argument. Was passiert dann, wenn automatisch ein Standardkonstruktor einer Basisklasse
Mohan
Ja. Wenn Sie es aufrufen super(), wird der Konstruktor der Superklasse aufgerufen , der keine Argumente akzeptiert. In ähnlicher Weise wird der Konstruktor mit 1 Argumenten aufgerufen, wenn Sie dies tun super(arg1), und so weiter.
Aioobe
Wenn es in der Basisklasse keinen Konstruktor ohne Argument gab, was passiert dann, wenn die abgeleitete Klasse super () aufruft?
Mohan
1
Nichts. Es wird nicht kompiliert. Wenn Sie selbst einen Konstruktor angeben, wird der automatische Konstruktor / default / no-argument nicht generiert und ist daher super()kein gültiger Aufruf.
Aioobe
29

Wird super () verwendet, um den übergeordneten Konstruktor aufzurufen?

Ja.

Bitte erklären Sie über Super ().

super()ist eine spezielle Verwendung des superSchlüsselworts, bei dem Sie einen parameterlosen übergeordneten Konstruktor aufrufen. Im Allgemeinen kann das superSchlüsselwort verwendet werden, um überschriebene Methoden aufzurufen, auf versteckte Felder zuzugreifen oder den Konstruktor einer Oberklasse aufzurufen.

Hier ist das offizielle Tutorial

Heinzi
quelle
5
super()wird verwendet, um den übergeordneten Konstruktor aufzurufen, super.myMethod()wird verwendet, um eine überschriebene Methode aufzurufen.
Sean Patrick Floyd
2
@seanizer oder eine andere Methode der Oberklasse (einschließlich Statik), wenn sie im Geltungsbereich liegt. Super ist nur ein Verweis auf Ihre Basisklasse.
Atamanroman
3
Ich glaube nicht, dass super () verwendet wird, um Basisklassenmethoden aufzurufen. Sie können jedoch super.method () verwenden.
Dheeraj Joshi
@seanizer, @Dheeraj: Danke für dein Feedback, ich habe meine Antwort angepasst.
Heinzi
7

Das Aufrufen des Super-Konstruktors ohne Argumente ist nur eine Verschwendung von Bildschirmplatz und Programmierzeit. Der Compiler generiert genau den gleichen Code, unabhängig davon, ob Sie ihn schreiben oder nicht.

class Explicit() {
    Explicit() {
        super();
    }
}

class Implicit {
    Implicit() {
    }
}
Roland Illig
quelle
Ich fand es in wenigen Klassen verwendet, nicht sicher, was der Zweck war. Ihre Antwort ist hilfreich.
Iprashant
6

Ja, super()(Kleinbuchstaben) ruft einen Konstruktor der übergeordneten Klasse auf. Sie können Argumente einschließen:super(foo, bar)

Es gibt auch ein superSchlüsselwort, das Sie in Methoden verwenden können, um eine Methode der Oberklasse aufzurufen

Ein schnelles Google für "Java Super" führt dazu

Bozho
quelle
4

Das ist richtig. Super wird verwendet, um den übergeordneten Konstruktor aufzurufen. Angenommen, Sie haben einen solchen Codeblock

class A{
    int n;
    public A(int x){
        n = x;
    }
}

class B extends A{
    int m;
    public B(int x, int y){
        super(x);
        m = y;
    }
}

Anschließend können Sie der Mitgliedsvariablen n einen Wert zuweisen.

Sagar V.
quelle
2

Ich habe alle Antworten gesehen. Aber alle haben vergessen, einen sehr wichtigen Punkt zu erwähnen:

super () sollte in der ersten Zeile des Konstruktors aufgerufen oder verwendet werden.

Pritam Banerjee
quelle
1

Einfach super (); Allein wird der Standardkonstruktor aufgerufen, wenn er in der Oberklasse einer Klasse vorhanden ist. Sie müssen den Standardkonstruktor jedoch explizit selbst schreiben. Wenn Sie kein Java ohne Implementierungen für Sie generieren, speichern Sie super (). Dies bezieht sich auf das universelle Superklassenobjekt und kann nicht in einer Unterklasse aufgerufen werden.

public class Alien{
   public Alien(){ //Default constructor is written out by user
   /** Implementation not shown…**/
   }
}

public class WeirdAlien extends Alien{
   public WeirdAlien(){
   super(); //calls the default constructor in Alien.
   }

}
TheArchon
quelle
Ohne Argumente .
Marquis von Lorne
1

In der Selenautomatisierung haben Sie beispielsweise ein PageObject, das den Konstruktor des übergeordneten Elements wie folgt verwenden kann:

public class DeveloperSteps extends ScenarioSteps {

public DeveloperSteps(Pages pages) {
    super(pages);
}........
Todd Zhang
quelle
1

Ich möchte mit Codes teilen, was ich verstanden habe.

Das Super-Schlüsselwort in Java ist eine Referenzvariable, mit der übergeordnete Klassenobjekte referenziert werden. Es wird hauptsächlich in folgenden Zusammenhängen verwendet:

1. Verwendung von Super mit Variablen:

class Vehicle 
{ 
    int maxSpeed = 120; 
} 

/* sub class Car extending vehicle */
class Car extends Vehicle 
{ 
    int maxSpeed = 180; 

    void display() 
    { 
        /* print maxSpeed of base class (vehicle) */
        System.out.println("Maximum Speed: " + super.maxSpeed); 
    } 
} 

/* Driver program to test */
class Test 
{ 
    public static void main(String[] args) 
    { 
        Car small = new Car(); 
        small.display(); 
    } 
} 

Ausgabe:-

Maximum Speed: 120
  1. Verwendung von Super mit Methoden:
/* Base class Person */
class Person 
{ 
    void message() 
    { 
        System.out.println("This is person class"); 
    } 
} 

/* Subclass Student */
class Student extends Person 
{ 
    void message() 
    { 
        System.out.println("This is student class"); 
    } 

    // Note that display() is only in Student class 
    void display() 
    { 
        // will invoke or call current class message() method 
        message(); 

        // will invoke or call parent class message() method 
        super.message(); 
    } 
} 

/* Driver program to test */
class Test 
{ 
    public static void main(String args[]) 
    { 
        Student s = new Student(); 

        // calling display() of Student 
        s.display(); 
    } 
}

Ausgabe:-

This is student class
This is person class

3. Verwendung von Super mit Konstruktoren:

class Person 
{ 
    Person() 
    { 
        System.out.println("Person class Constructor"); 
    } 
} 

/* subclass Student extending the Person class */
class Student extends Person 
{ 
    Student() 
    { 
        // invoke or call parent class constructor 
        super(); 

        System.out.println("Student class Constructor"); 
    } 
} 

/* Driver program to test*/
class Test 
{ 
    public static void main(String[] args) 
    { 
        Student s = new Student(); 
    } 
} 

Ausgabe:-

Person class Constructor
Student class Constructor
Gulsan Borbhuiya
quelle
0

Konstruktoren
In einem Konstruktor können Sie ihn ohne Punkt verwenden, um einen anderen Konstruktor aufzurufen. superruft einen Konstruktor in der Oberklasse auf; thisruft einen Konstruktor in dieser Klasse auf:

public MyClass(int a) {
  this(a, 5);  // Here, I call another one of this class's constructors.
}

public MyClass(int a, int b) {
  super(a, b);  // Then, I call one of the superclass's constructors.
}

superist nützlich, wenn sich die Oberklasse selbst initialisieren muss. thisDies ist nützlich, damit Sie den gesamten Hard-Initialisierungscode nur einmal in einen der Konstruktoren schreiben und von allen anderen, viel einfacher zu schreibenden Konstruktoren aufrufen können.

Methoden
In jeder Methode können Sie sie mit einem Punkt verwenden, um eine andere Methode aufzurufen. super.method()ruft eine Methode in der Oberklasse auf; this.method()ruft eine Methode in dieser Klasse auf:

public String toString() {
  int    hp   = this.hitpoints();  // Calls the hitpoints method in this class
                                   //   for this object.
  String name = super.name();      // Calls the name method in the superclass
                                   //   for this object.

  return "[" + name + ": " + hp + " HP]";
}

superist in einem bestimmten Szenario nützlich: Wenn Ihre Klasse dieselbe Methode wie Ihre Oberklasse hat, geht Java davon aus, dass Sie die in Ihrer Klasse haben möchten. superHier können Sie stattdessen nach der Methode der Oberklasse fragen. thisist nur nützlich, um Ihren Code besser lesbar zu machen.

Olathe
quelle
0

Das Schlüsselwort super kann verwendet werden, um den Konstruktor der Oberklasse aufzurufen und auf ein Mitglied der Oberklasse zu verweisen

Wenn Sie anrufen super () mit den richtigen Argumenten, nennen wir tatsächlich den Konstruktor Box , die Variablen initialisiert Breite , Höhe und Tiefe , unter Verwendung der Werte der entsprechenden Parameter , um es bezeichnet. Sie müssen nur noch das Mehrwertgewicht initialisieren. Bei Bedarf können Sie jetzt die Variablen Box als privat klassifizieren . Tragen Sie in die Felder des privaten Modifikators der Box-Klasse ein und stellen Sie sicher, dass Sie problemlos darauf zugreifen können.

In der Oberklasse können sich mehrere überladene Versionskonstruktoren befinden, sodass Sie die Methode super () mit unterschiedlichen Parametern aufrufen können . Das Programm führt den Konstruktor aus, der den angegebenen Argumenten entspricht.

public class Box {

    int width;
    int height;
    int depth;

    Box(int w, int h, int d) {
        width = w;
        height = h;
        depth = d;
    }

    public static void main(String[] args){
        HeavyBox heavy = new HeavyBox(12, 32, 23, 13);
    }

}

class HeavyBox extends Box {

    int weight;

    HeavyBox(int w, int h, int d, int m) {

        //call the superclass constructor
        super(w, h, d);
        weight = m;
    }

}
Luchnik
quelle
0

Super ist ein Schlüsselwort. Es wird innerhalb einer Unterklassenmethodendefinition verwendet, um eine in der Oberklasse definierte Methode aufzurufen. Private Methoden der Oberklasse können nicht aufgerufen werden. Nur öffentliche und geschützte Methoden können mit dem Schlüsselwort super aufgerufen werden. Es wird auch von Klassenkonstruktoren verwendet, um Konstruktoren der übergeordneten Klasse aufzurufen.

Weitere Erklärungen finden Sie hier .

Otoloye
quelle
0

Wie bereits erwähnt, befindet sich im Standardkonstruktor ein implizites super (), das in der ersten Zeile des Konstruktors aufgerufen wird .

Dieses super () ruft automatisch eine Kette von Konstruktoren auf, die am Anfang der Klassenhierarchie beginnen und sich in der Hierarchie nach unten bewegen.

Wenn die Klassenhierarchie des Programms mehr als zwei Klassen enthält , wird der Standardkonstruktor der obersten Klasse zuerst aufgerufen .

Hier ist ein Beispiel dafür:

class A {
    A() {
    System.out.println("Constructor A");
    }
}

class B extends A{

    public B() {
    System.out.println("Constructor B");
    }
}

class C extends B{ 

    public C() {
    System.out.println("Constructor C");
    }

    public static void main(String[] args) {
    C c1 = new C();
    }
} 

Das obige würde ausgeben:

Constructor A
Constructor B
Constructor C
Mark Burleigh
quelle