super () en Java

¿Se super()usa para llamar al constructor padre? Por favor explique super().

super() llama al constructor padre sin argumentos.

Se puede usar también con argumentos. Es decir, super(argument1)y llamará al constructor que acepta 1 parámetro del tipo de argument1(si existe).

También se puede usar para llamar a métodos del padre. Es decirsuper.aMethod()

Más información y tutorial aquí.

Algunos hechos:

1. super() se usa para llamar al padre inmediato.
2. super() se puede usar con miembros de instancia, es decir, variables de instancia y métodos de instancia.
3. super() se puede usar dentro de un constructor para llamar al constructor de la clase padre.

Bien, ahora implementemos prácticamente estos puntos de super().

Vea la diferencia entre el programa 1 y 2. Aquí, el programa 2 prueba nuestra primera declaración de super()en Java.

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

Salida:

200
200

Ahora echa un vistazo al programa 2 e intenta descubrir la diferencia principal.

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

Salida:

100
200

En el programa 1, la salida era solo de la clase derivada. No pudo imprimir la variable de la clase base ni la clase padre. Pero en el programa 2, utilizamos super()con variable aal imprimir su salida, y en lugar de imprimir el valor de variable ade la clase derivada, imprimió el valor de variable ade la clase base. Por lo tanto, demuestra que super()se usa para llamar al padre inmediato.

OK, ahora mira la diferencia entre el programa 3 y el programa 4.

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

Salida:

200

Aquí la salida es 200. Cuando llamamos Show(), se llamó a la Show()función de la clase derivada. Pero, ¿qué debemos hacer si queremos llamar a la Show()función de la clase padre? Echa un vistazo al programa 4 para la solución.

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

Salida:

100
200

Aquí estamos obteniendo dos salidas, 100 y 200. Cuando Show()se invoca la función de la clase derivada, primero llama a la Show()función de la clase padre, porque dentro de la Show()función de la clase derivada, llamamos a la Show()función de la clase padre poniendo la superpalabra clave antes del nombre de la función.

Artículo fuente: Java: Calling super ()

Si. super(...)invocará al constructor de la superclase.

Ilustración:

Ejemplo independiente:

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

Huellas dactilares:

Constructing an animal: From Dog constructor
Constructing a dog.

¿Se usa super () para llamar al constructor padre?

Si.

Por favor explique sobre Super ().

super()es un uso especial de la superpalabra clave donde se llama un constructor padre sin parámetros. En general, la superpalabra clave se puede usar para llamar a métodos anulados, acceder a campos ocultos o invocar el constructor de una superclase.

Aquí está el tutorial oficial.

Llamar al súper constructor sin argumentos es solo una pérdida de espacio en la pantalla y tiempo de programación. El compilador genera exactamente el mismo código, lo escriba o no.

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

class Implicit {
    Implicit() {
    }
}

Sí, super()(en minúsculas) llama a un constructor de la clase padre. Puede incluir argumentos:super(foo, bar)

También hay una superpalabra clave, que puede usar en métodos para invocar un método de la superclase

Un rápido google para "Java super" resulta en esto

Eso es correcto. Super se usa para llamar al constructor padre. Supongamos que tiene un bloque de código así

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

Luego puede asignar un valor a la variable miembro n.

He visto todas las respuestas. Pero todos olvidaron mencionar un punto muy importante:

super () debería llamarse o usarse en la primera línea del constructor.

Simplemente super (); solo llamará al constructor predeterminado, si existe de la superclase de una clase. Pero debe escribir explícitamente el constructor predeterminado usted mismo. Si no lo hace, Java generará uno para usted sin implementaciones, guarde super (); , refiriéndose al Objeto universal de Superclase, y no puede llamarlo en una subclase.

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

}

Por ejemplo, en la automatización de selenio, tiene un PageObject que puede usar el constructor de su padre de la siguiente manera:

public class DeveloperSteps extends ScenarioSteps {

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

Me gustaría compartir con códigos todo lo que entendí.

La palabra clave super en java es una variable de referencia que se utiliza para referirse a objetos de clase primaria. Se utiliza principalmente en los siguientes contextos: -

1. Uso de super con variables:

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

Salida:-

Maximum Speed: 120

2. Uso de super con métodos:

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

Salida:-

This is student class
This is person class

3. Uso de super con constructores:

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

Salida:-

Person class Constructor
Student class Constructor

Constructores
En un constructor, puede usarlo sin un punto para llamar a otro constructor. superllama a un constructor en la superclase; thisllama a un constructor en esta clase:

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

superes útil si la superclase necesita inicializarse. thises útil para permitirle escribir todo el código de inicialización duro solo una vez en uno de los constructores y llamarlo desde todos los otros constructores, mucho más fáciles de escribir.

Métodos
En cualquier método, puede usarlo con un punto para llamar a otro método. super.method()llama a un método en la superclase; this.method()llama a un método en esta clase:

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

superes útil en un determinado escenario: si su clase tiene el mismo método que su superclase, Java asumirá que desea el de su clase; superle permite solicitar el método de la superclase en su lugar. thises útil solo como una forma de hacer que su código sea más legible.

La palabra clave super puede usarse para llamar al constructor de la superclase y para referirse a un miembro de la superclase

Cuando llama a super () con los argumentos correctos, en realidad llamamos al constructor Box , que inicializa las variables ancho , alto y profundidad , al que se hace referencia utilizando los valores de los parámetros correspondientes. Solo le queda inicializar su peso de valor agregado. Si es necesario, ahora puede hacer que las variables de clase Box sean privadas . Anote en los campos del modificador privado de clase Box y asegúrese de que puede acceder a ellos sin ningún problema.

En la superclase puede haber varios constructores de versiones sobrecargadas, por lo que puede llamar al método super () con diferentes parámetros. El programa realizará el constructor que coincide con los argumentos especificados.

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 es una palabra clave. Se utiliza dentro de una definición de método de subclase para llamar a un método definido en la superclase. No se pueden llamar métodos privados de la superclase. Solo los métodos públicos y protegidos pueden ser llamados por la palabra clave super. También lo usan los constructores de clases para invocar a los constructores de su clase padre.

Verifique aquí para más explicaciones.

Como se indicó, dentro del constructor predeterminado hay un super () implícito llamado en la primera línea del constructor.

Este super () llama automáticamente a una cadena de constructores que comienza en la parte superior de la jerarquía de clases y se mueve hacia abajo en la jerarquía.

Si hubiera más de dos clases en la jerarquía de clases del programa, primero se llamaría al constructor predeterminado de la clase superior .

Aquí hay un ejemplo de esto:

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

Lo anterior generaría:

Constructor A
Constructor B
Constructor C