super () w Javie

Czy super()służy do wywołania konstruktora nadrzędnego? Proszę wyjaśnić super().

super() wywołuje konstruktor nadrzędny bez argumentów.

Można go również używać z argumentami. Ie super(argument1)i wywoła konstruktor, który akceptuje 1 parametr typuargument1 (jeśli istnieje).

Można go również używać do wywoływania metod od rodzica. To znaczysuper.aMethod()

Więcej informacji i samouczek tutaj

Kilka faktów:

1. super() służy do połączenia z bezpośrednim rodzicem.
2. super() może być używany z elementami instancji, tj. zmiennymi instancji i metodami instancji.
3. super() można użyć w konstruktorze do wywołania konstruktora klasy nadrzędnej.

OK, teraz praktycznie zaimplementujmy te punkty super().

Sprawdź różnicę między programem 1 a 2. Tutaj program 2 potwierdza naszą pierwszą instrukcję super()w języku Java.

Program 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();
    }
}

Wynik:

200
200

Teraz sprawdź program 2 i spróbuj ustalić główną różnicę.

Program 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();
    }
}

Wynik:

100
200

W programie 1 dane wyjściowe pochodziły tylko z klasy pochodnej. Nie można wydrukować zmiennej ani klasy podstawowej, ani klasy nadrzędnej. Ale w programie 2 używaliśmy super()zmiennej apodczas drukowania danych wyjściowych, i zamiast awypisywać wartość zmiennej klasy pochodnej, wypisał wartość zmiennej aklasy bazowej. Udowadnia to, że super()służy do wywoływania bezpośredniego rodzica.

OK, teraz sprawdź różnicę między programem 3 a programem 4.

Program 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();
    }
}

Wynik:

200

Tutaj wyjście 200. Kiedy zadzwoniliśmy Show()The Show()funkcją klasy pochodnej została wywołana. Ale co powinniśmy zrobić, jeśli chcemy wywołać Show()funkcję klasy nadrzędnej? Sprawdź program 4 dla rozwiązania.

Program 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();
    }
}

Wynik:

100
200

Tutaj otrzymujemy dwa dane wyjściowe, 100 i 200. Kiedy Show()wywoływana jest funkcja klasy pochodnej, najpierw wywołuje Show()funkcję klasy nadrzędnej, ponieważ wewnątrz Show()funkcji klasy pochodnej wywołaliśmy Show()funkcję klasy nadrzędnej poprzez wstawienie superkluczowe przed nazwą funkcji.

Artykuł źródłowy: Java: Calling super ()

Tak. super(...)wywoła konstruktora superklasy.

Ilustracja:

Przykład samodzielny:

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

Wydruki:

Constructing an animal: From Dog constructor
Constructing a dog.

Czy funkcja super () służy do wywoływania konstruktora nadrzędnego?

Tak.

Pls wyjaśniają o Super ().

super()jest specjalnym zastosowaniem supersłowa kluczowego, w którym wywoływany jest konstruktor bez parametrów. Zasadniczo supersłowa kluczowego można używać do wywoływania przesłoniętych metod, uzyskiwania dostępu do ukrytych pól lub wywoływania konstruktora nadklasy.

Oto oficjalny samouczek

Nazywanie superstruktorem bez argumentów to tylko strata miejsca na ekranie i czas programisty. Kompilator generuje dokładnie ten sam kod, niezależnie od tego, czy go napiszesz, czy nie.

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

class Implicit {
    Implicit() {
    }
}

Tak, super()(małe litery) wywołuje konstruktora klasy nadrzędnej. Możesz dołączyć argumenty:super(foo, bar)

Istnieje również supersłowo kluczowe, którego można użyć w metodach w celu wywołania metody nadklasy

Skutkuje to szybkie google dla „Java super”

To jest poprawne. Super służy do wywołania konstruktora nadrzędnego. Załóżmy, że masz taki blok kodu

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

Następnie możesz przypisać wartość do zmiennej członka n.

Widziałem wszystkie odpowiedzi. Ale wszyscy zapomnieli wspomnieć o jednym bardzo ważnym punkcie:

super () należy wywołać lub użyć w pierwszym wierszu konstruktora.

Po prostu super (); samodzielnie wywoła domyślnego konstruktora, jeśli istnieje nadklasa klasy. Ale musisz sam napisać domyślny konstruktor. Jeśli nie, Java wygeneruje ją bez implementacji, zapisz super (); , odnosząc się do uniwersalnego obiektu nadklasy, i nie można go nazwać w podklasie.

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

}

Na przykład w automatyzacji selenu masz obiekt PageObject, który może używać konstruktora rodzica w następujący sposób:

public class DeveloperSteps extends ScenarioSteps {

public DeveloperSteps(Pages pages) {
    super(pages);
}........

Chciałbym podzielić się z kodami, co rozumiem.

Super słowo kluczowe w java jest zmienną referencyjną, która służy do odwoływania się do obiektów klasy nadrzędnej. Jest głównie używany w następujących kontekstach:

1. Zastosowanie super ze zmiennymi:

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

Wynik:-

Maximum Speed: 120

2. Zastosowanie super z metodami:

/* 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(); 
    } 
}

Wynik:-

This is student class
This is person class

3. Zastosowanie super z konstruktorami:

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

Wynik:-

Person class Constructor
Student class Constructor

Konstruktory
W konstruktorze można go używać bez kropki, aby wywoływać innego konstruktora. superwywołuje konstruktora w nadklasie; thiswywołuje konstruktor w tej klasie:

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

superjest przydatny, jeśli superklasa musi się zainicjować. thisprzydaje się, abyś mógł napisać cały twardy kod inicjujący tylko raz w jednym z konstruktorów i wywołać go z wszystkich innych, znacznie łatwiejszych do napisania konstruktorów.

Metody
W dowolnej metodzie można użyć kropki, aby wywołać inną metodę. super.method()wywołuje metodę w nadklasie; this.method()wywołuje metodę w tej klasie:

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

superjest przydatny w pewnym scenariuszu: jeśli twoja klasa ma taką samą metodę jak twoja nadklasa, Java założy, że chcesz tę w swojej klasie; superpozwala zamiast tego poprosić o metodę nadklasy. thisjest przydatny tylko jako sposób na zwiększenie czytelności kodu.

Super kluczowe mogą być wykorzystane do wywołania konstruktora klasy nadrzędnej i zwrócić się do członka nadklasy

Kiedy wywołujesz super () z właściwymi argumentami, faktycznie wywołujemy konstruktor Box , który inicjuje zmienne szerokość , wysokość i głębokość , do których się odwołuje, używając wartości odpowiednich parametrów. Pozostaje tylko zainicjować jego wartość dodaną. Jeśli to konieczne, możesz teraz zrobić zmienne klasowe Box jako prywatne . Umieść w polach prywatnego modyfikatora klasy Box i upewnij się, że masz do nich dostęp bez żadnych problemów.

W nadklasie może znajdować się kilka przeciążonych wersji konstruktorów, dzięki czemu można wywołać metodę super () z różnymi parametrami. Program wykona konstruktor, który pasuje do podanych argumentów.

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 jest słowem kluczowym. Jest używany w definicji metody podklasy, aby wywołać metodę zdefiniowaną w nadklasie. Nie można wywoływać prywatnych metod nadklasy. Super słowo kluczowe może wywoływać tylko metody publiczne i chronione. Jest również używany przez konstruktorów klas do wywoływania konstruktorów swojej klasy nadrzędnej.

Sprawdź tutaj, aby uzyskać dalsze wyjaśnienia.

Jak wspomniano, wewnątrz domyślnego konstruktora znajduje się niejawna funkcja super () wywołana w pierwszym wierszu konstruktora.

Ta super () automatycznie wywołuje łańcuch konstruktorów rozpoczynający się na szczycie hierarchii klas i przesuwa się w dół hierarchii.

Gdyby w hierarchii klas programu były więcej niż dwie klasy, domyślny konstruktor najwyższej klasy zostałby wywołany jako pierwszy .

Oto przykład:

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

Powyższe spowoduje, że:

Constructor A
Constructor B
Constructor C