Tratando de entender cuándo se llama al método super (). En el siguiente código, la clase Child tiene un constructor sin argumentos con this (), por lo que el compilador no puede insertar super (). Entonces, ¿cómo se llama al constructor padre?

public class Parent
{
    public Parent()
    {
        System.out.println("In parent constructor");
    }
 }


public class Child extends Parent
{
private int age;

public Child()
{   
    this(10);
    System.out.println("In child constructor with no argument");
}

public Child(int age)
{
    this.age = age;
    System.out.println("In child constructor with argument");
}

public static void main(String[] args)
{
    System.out.println("In main method");
    Child child = new Child();
}

}

Salida:

In main method

In parent constructor

In child constructor with argument

In child constructor with no argument
4
puvi 29 ene. 2016 a las 23:17

3 respuestas

La mejor respuesta

Esto es lo que pasa:

public class Parent
{
    public Parent()
    {
        System.out.println("In parent constructor"); // 4 <------
    }
}


public class Child extends Parent
{
    private int age;

    public Child()
    {
        this(10); // 2 <------
        System.out.println("In child constructor with no argument"); // 6 <------
    }

    public Child(int age)
    {
        // 3 -- implicit call to super()  <------
        this.age = age;
        System.out.println("In child constructor with argument"); // 5 <------
    }

    public static void main(String[] args)
    {
        System.out.println("In main method"); // 1 <------
        Child child = new Child();
    }
}
6
Mohammed Aouf Zouag 29 ene. 2016 a las 20:19

Antes de una respuesta me gustaría aclarar algunas cosas que considero importantes para esta pregunta:

  • Cuando no declaras un constructor para una clase, el compilador de Java crea un constructor predeterminado en tiempo de compilación.

  • Cuando tenemos una subclase que no llama a su constructor padre. Nuevamente, Java construye el constructor predeterminado para el padre y luego ejecuta el constructor de la subclase (porque cuando un hijo es instanciado primero se crea su padre).

Entonces en este caso:

1) Ejecute el método principal público. 2) Instancia del nuevo hijo 2.1) 'Construir constructor hijo' pero el primer compilador de Java construye el constructor predeterminado para su padre. 2.2) Construir hijo (aquel que no recibe parámetros) 3) Ejecutar el segundo constructor con el parámetro de edad del constructor predeterminado (construcción anterior).

Espero que eso ayude.

0
Jessica 29 ene. 2016 a las 23:04

super() se llama implícitamente antes de la primera línea de cualquier constructor, a menos que llame explícitamente a super() o una sobrecarga en sí, o la clase sea java.lang.Object.

1
Mohammed Aouf Zouag 29 ene. 2016 a las 21:10