Considere que hay tres clases A, B y C. La clase A no tiene un constructor, la clase B tiene un constructor y la clase C tiene un constructor parametrizado. algo como el ejemplo que se da a continuación.


public class ClassA {

}

public class ClassB extends ClassA {

    public ClassB() {
        System.out.println("Default cons Class B");
    }

}

public class ClassC extends ClassB {

    public ClassC(int a, int b) {
        System.out.println("This is class C "+a+ "and"+ b );

    }
    public static void main(String args[]) {
        ClassC c = new ClassC(2,3);
    }
}

Salida:

Contras por defecto Clase C

Esto es clase C 2 y 3

Pregunta 1:

Para construir el objeto C construye B y para construir B construye A primero. Aunque no hay ningún constructor predeterminado en la clase A definido, el programa funciona bien construyendo su propio constructor predeterminado y la clase B llama a super (). Sin embargo, no tengo ningún problema aquí cuando cambio la Clase B algo como esto

public class ClassB extends ClassA {

    public ClassB(int a, int b) {
        System.out.println("This is class C "+a+ "and"+ b );
    }   
}

Recibo un error

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
    Implicit super constructor ClassB() is undefined. Must explicitly invoke another constructor

    at ClassC.<init>(ClassC.java:4)
    at ClassC.main(ClassC.java:10)

¿Por qué tenemos que especificar implícitamente el superconstructor ClassB ()? Funcionó bien para el primer ejemplo aunque no hay ningún superconstructor en ClassA (). Me pregunto si, de forma predeterminada, el constructor de C llama por defecto al constructor no especificado de B como lo hizo para la Clase A.

0
Iniyan Selvan 26 ene. 2016 a las 23:24

2 respuestas

La mejor respuesta

Si especifica al menos un constructor en una clase, ya no se crea un constructor predeterminado para usted.

Si no especifica qué constructor padre llamar en su subclase, el que toma 0 parámetros se usa por defecto.

Dado que agregó un constructor a la clase B que toma dos parámetros enteros, ahora tiene que llamarlo así desde C, ya que ya no hay un constructor que no tome parámetros en la clase B:

public ClassC(int a, int b) {
    super(a, b);
    System.out.println("This is class C "+a+ "and"+ b );
}
4
George Mulligan 26 ene. 2016 a las 20:40

Porque para crear una instancia de C, la JVM llama a los constructores de la jerarquía de clases.

Entonces, cuando crea C, en realidad llama primero al constructor de A, luego de B, luego de C. Implícitamente, se llama a super() si no se especifica nada más.

Si crea un constructor que toma parámetros explícitamente, eso anula el constructor predeterminado

public B() {
    //default constructor
}

Lo que significa que Java no podrá invocarlo implícitamente, ya que no existe, por lo que debe llamarlo usted mismo con

public C(int a, int b) {
    super(a, b);
}
1
EpicPandaForce 26 ene. 2016 a las 20:29