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

Estoy lidiando con una clase que extiende 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, ya que siempre acabo de acceder a los métodos de la superclase sin tener que llamar a super();

Existe una llamada implícita a 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, puede usar la llamada a super() con argumentos si el constructor padre toma los parámetros y desea especificarlos. Además, si el constructor del padre toma los parámetros, y no tiene un constructor predeterminado sin parámetros, necesitará llamar a super() con argumento (s).

Un ejemplo, donde la llamada explícita a super() le da un control adicional sobre el título del marco:

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

Una llamada al constructor vacío super() tu clase principal se realiza automáticamente cuando no lo haces tú mismo. 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 comstackdor le pedirá que llame a super con los argumentos apropiados. El comstackdor 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 a 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.

Podemos acceder a los elementos de la clase superior mediante el uso de un método súper

Considere que tenemos dos clases, clases para padres y clases para niños, con diferentes implementaciones del método foo. 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(); } } 

Simplemente llama al constructor predeterminado de la superclase.

Podemos acceder a miembros de SuperClass usando 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). Considera esta clase, Superclase:

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

// Aquí hay una subclase, llamada Subclase, que reemplaza a 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 la Subclase, el nombre simple printMethod() refiere al declarado en Subclase, que anula el de Superclass. Entonces, para referirse a printMethod() heredado de Superclass, Subclass debe usar un nombre calificado, usando super como se muestra. La comstackción y ejecución de Subclase imprime lo siguiente:

 Printed in Superclass. Printed in Subclass