super () in Java

Viene super()utilizzato per chiamare il costruttore principale? Per favore, spiega super().

super() chiama il costruttore principale senza argomenti.

Può essere utilizzato anche con argomenti. Cioè super(argument1)e chiamerà il costruttore che accetta 1 parametro del tipo di argument1(se esiste).

Inoltre può essere usato per chiamare metodi dal genitore. iesuper.aMethod()

Maggiori informazioni e tutorial qui

Alcuni fatti:

1. super() è usato per chiamare il genitore immediato.
2. super() può essere utilizzato con membri di istanza, ovvero variabili di istanza e metodi di istanza.
3. super() può essere utilizzato in un costruttore per chiamare il costruttore della classe genitore.

OK, ora implementiamo praticamente questi punti di super().

Scopri la differenza tra il programma 1 e 2. Qui, il programma 2 dimostra la nostra prima affermazione super()in Java.

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

Produzione:

200
200

Ora controlla il programma 2 e prova a capire la differenza principale.

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

Produzione:

100
200

Nel programma 1, l'output era solo della classe derivata. Non è stato possibile stampare la variabile né della classe base né della classe genitore. Ma nel programma 2, abbiamo usato super()con la variabile adurante la stampa del suo output e invece di stampare il valore della variabile adella classe derivata, ha stampato il valore della variabile adella classe base. Quindi dimostra che super()viene utilizzato per chiamare il genitore immediato.

OK, ora controlla la differenza tra il programma 3 e il programma 4.

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

Produzione:

200

Qui l'output è 200. Quando abbiamo chiamato Show(), è stata chiamata la Show()funzione della classe derivata. Ma cosa dovremmo fare se vogliamo chiamare la Show()funzione della classe genitore? Controlla il programma 4 per la soluzione.

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

Produzione:

100
200

Qui stiamo ottenendo due output, 100 e 200. Quando Show()viene invocata la funzione della classe derivata, viene prima chiamata la Show()funzione della classe genitore, perché all'interno della Show()funzione della classe derivata, abbiamo chiamato la Show()funzione della classe genitore mettendo la superparola chiave prima del nome della funzione.

Articolo di origine: Java: Calling super ()

Sì. super(...)invocherà il costruttore della superclasse.

Illustrazione:

Esempio autonomo:

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

stampe:

Constructing an animal: From Dog constructor
Constructing a dog.

Super () viene utilizzato per chiamare il costruttore principale?

Sì.

Spieghiamo su Super ().

super()è un uso speciale della superparola chiave in cui si chiama un costruttore principale senza parametri. In generale, la superparola chiave può essere utilizzata per chiamare metodi sostituiti, accedere a campi nascosti o invocare il costruttore di una superclasse.

Ecco il tutorial ufficiale

Chiamare il super-costruttore senza argomenti è solo una perdita di spazio sullo schermo e del tempo del programmatore. Il compilatore genera esattamente lo stesso codice, che tu lo scriva o meno.

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

class Implicit {
    Implicit() {
    }
}

Sì, super()(lettere minuscole) chiama un costruttore della classe genitore. Puoi includere argomenti:super(foo, bar)

C'è anche un super parola chiave, che puoi usare nei metodi per invocare un metodo della superclasse

Un rapido google per "Java super" risulta in questo

È corretto. Super viene utilizzato per chiamare il costruttore principale. Supponiamo quindi di avere un blocco di codice in questo modo

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

Quindi è possibile assegnare un valore alla variabile membro n.

Ho visto tutte le risposte. Ma tutti hanno dimenticato di menzionare un punto molto importante:

super () dovrebbe essere chiamato o usato nella prima riga del costruttore.

Solo super (); da solo chiamerà il costruttore predefinito, se esiste della superclasse di una classe. Ma devi scrivere esplicitamente il costruttore predefinito tu stesso. Se non lo fai, Java ne genererà uno per te senza implementazioni, salva super (); , facendo riferimento all'oggetto Superclass universale e non puoi chiamarlo in una sottoclasse.

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

}

Ad esempio, nell'automazione del selenio, hai un PageObject che può usare il costruttore del suo genitore in questo modo:

public class DeveloperSteps extends ScenarioSteps {

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

Vorrei condividere con i codici qualunque cosa io abbia capito.

La super parola chiave in Java è una variabile di riferimento che viene utilizzata per fare riferimento agli oggetti della classe genitore. È principalmente utilizzato nei seguenti contesti: -

1. Uso di super con variabili:

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

Produzione:-

Maximum Speed: 120

2. Uso di super con metodi:

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

Produzione:-

This is student class
This is person class

3. Uso di super con costruttori:

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

Produzione:-

Person class Constructor
Student class Constructor

Costruttori
In un costruttore, è possibile utilizzarlo senza un punto per chiamare un altro costruttore. superchiama un costruttore nella superclasse; thischiama un costruttore in questa classe:

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

superè utile se la superclasse deve inizializzarsi. thisè utile per consentire di scrivere tutto il codice di inizializzazione rigido solo una volta in uno dei costruttori e di chiamarlo da tutti gli altri costruttori molto più facili da scrivere.

Metodi
In qualsiasi metodo, è possibile utilizzarlo con un punto per chiamare un altro metodo. super.method()chiama un metodo nella superclasse; this.method()chiama un metodo in questa classe:

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

superè utile in un determinato scenario: se la tua classe ha lo stesso metodo della tua superclasse, Java supporrà che tu voglia quello della tua classe; superti permette invece di richiedere il metodo della superclasse. thisè utile solo come modo per rendere il tuo codice più leggibile.

Il super parola chiave può essere utilizzata per chiamare il costruttore della superclasse e fare riferimento a un membro della superclasse

Quando chiami super () con gli argomenti giusti, in realtà chiamiamo il costruttore Box , che inizializza le variabili larghezza , altezza e profondità , a cui fa riferimento utilizzando i valori dei parametri corrispondenti. Resta solo da inizializzare il suo valore aggiunto. Se necessario, ora puoi eseguire le variabili di classe Box come private . Metti giù nei campi del modificatore privato della classe Box e assicurati di poter accedervi senza problemi.

Nella superclasse possono esserci diversi costruttori di versioni sovraccaricate, quindi puoi chiamare il metodo super () con parametri diversi. Il programma eseguirà il costruttore che corrisponde agli argomenti specificati.

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 è una parola chiave. Viene utilizzato all'interno di una definizione del metodo della sottoclasse per chiamare un metodo definito nella superclasse. I metodi privati ​​della superclasse non possono essere chiamati. Solo i metodi pubblici e protetti possono essere chiamati dalla super parola chiave. È anche usato dai costruttori di classi per invocare i costruttori della sua classe genitore.

Controlla qui per ulteriori spiegazioni.

Come detto, all'interno del costruttore predefinito c'è un super () implicito chiamato sulla prima riga del costruttore.

Questo super () chiama automaticamente una catena di costruttori che parte dall'alto della gerarchia di classi e si sposta in basso nella gerarchia.

Se ci fossero più di due classi nella gerarchia di classi del programma, il costruttore predefinito di prima classe verrebbe chiamato per primo .

Ecco un esempio di questo:

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

Quanto sopra avrebbe prodotto:

Constructor A
Constructor B
Constructor C