super () in Java

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

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

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.

Quellartikel: Java: Aufruf von super ()

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

Illustration:

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.

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

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

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

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.

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.

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

}

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

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

2. 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

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.

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

}

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 .

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