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

Una llamada al constructor vacío de tu clase padre super() 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 compilador requerirá que llame a super con los argumentos apropiados. El compilador se asegurará de que instancies la clase correctamente. Así que esto no es algo de lo que tengas que preocuparte demasiado.

Si llama super() en su constructor o no, no afecta su capacidad de llamar a los métodos de su clase padre.

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

Podemos acceder a los elementos de super class usando super method

Considere que tenemos dos clases, la clase Padre y la clase Hijo, con diferentes implementaciones del método foo. Ahora en la clase hijo 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 los miembros de SuperClass usando super()

Si su método anula uno de los métodos de su superclase, puede invocar el método anulado 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, Superclase:

public class Superclass {

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

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

Printed in Superclass.
Printed in Subclass