¿Por qué llamar a super() en un constructor?

Question

Estoy tratando con una clase que amplía JFrame.

No es mi código y hace una llamada a super antes de que comience a construir la GUI. Me pregunto por qué se hace esto porque siempre acabo de acceder a los métodos de la superclase sin tener que llamar al super();

Answer 1

Hay una llamada implícita al super() sin argumentos para todas las clases que tienen un elemento primario, que es cada clase definida por el usuario en Java, por lo que no es necesario llamarlo explícitamente. Sin embargo, usted puede utilizar la llamada al super() con argumentos si el constructor padre toma los parámetros, y desea especificarlos. Además, si el constructor padre toma los parámetros, y no tiene un constructor predeterminado sin parámetros, necesitará para llamar al con argumento (s).

Un ejemplo, donde la llamada explícita a super() le da un control extra sobre el título de la trama:

class MyFrame extends JFrame 
{ 
    public MyFrame() { 
     super("My Window Title"); 
     ... 
    } 
} 

Answer 2

Una llamada al constructor vacío de su clase primaria super() se realiza automáticamente cuando usted no lo hace. Esa es la razón por la que nunca has tenido que hacerlo en tu código. Fue hecho por ti.

Cuando su superclase no tiene un constructor no-arg, el compilador le pedirá que llame al super con los argumentos apropiados. El compilador se asegurará de que crea una instancia de la clase correctamente. Entonces, esto no es algo de lo que tengas que preocuparte demasiado.

Ya sea que llame al super() en su constructor o no, no afecta su capacidad para llamar a los métodos de su clase principal.

Como nota al margen, algunos dicen que generalmente es mejor hacer esa llamada manualmente por razones de claridad.

Answer 3

Simplemente llama al constructor predeterminado de la superclase.

Answer 4

podemos tener acceso a los miembros de la superclase utilizando super()

Si su método anula uno de los métodos de su superclase, puede invocar el método reemplazado mediante el uso de la palabra clave super. También puede usar super para referirse a un campo oculto (aunque se desaconseja ocultar campos). Considere esta clase, la superclase:

public class Superclass { 

    public void printMethod() { 
     System.out.println("Printed in Superclass."); 
    } 
} 

// Aquí es una subclase, llamado subclase, que anula printMethod():

public class Subclass extends Superclass { 

    // overrides printMethod in Superclass 
    public void printMethod() { 
     super.printMethod(); 
     System.out.println("Printed in Subclass"); 
    } 
    public static void main(String[] args) { 
     Subclass s = new Subclass(); 
     s.printMethod();  
    } 
} 

Dentro de subclase, la simple nombre printMethod() se refiere a la declarada en la subclase, la cual anula el de Superclase. Entonces, para referirse a printMethod() heredado de Superclass, Subclass debe usar un nombre calificado, usando super como se muestra.Compilar y ejecutar copias Subclase lo siguiente:

Printed in Superclass. 
Printed in Subclass 

Answer 5

Nos puede acceder a los elementos súper clase utilizando el método súper

Considere tenemos dos clases, la clase dominante y la clase del niño, con diferentes implementaciones de foo métodos. Ahora en la clase secundaria si queremos llamar al método foo de la clase padre, podemos hacerlo por super.foo(); también podemos acceder a los elementos padre mediante el método super().

class parent { 
    String str="I am parent"; 
    //method of parent Class 
    public void foo() { 
     System.out.println("Hello World " + str); 
    } 
} 

class child extends parent { 
    String str="I am child"; 
    // different foo implementation in child Class 
    public void foo() { 
     System.out.println("Hello World "+str); 
    } 

    // calling the foo method of parent class 
    public void parentClassFoo(){ 
     super.foo(); 
    } 

    // changing the value of str in parent class and calling the foo method of parent class 
    public void parentClassFooStr(){ 
     super.str="parent string changed"; 
     super.foo(); 
    } 
} 


public class Main{ 
     public static void main(String args[]) { 
      child obj = new child(); 
      obj.foo(); 
      obj.parentClassFoo(); 
      obj.parentClassFooStr(); 
     } 
    }