¿Por qué esta () y super () tienen que ser la primera declaración en un constructor?

La clase padre ' constructor necesita ser llamado antes que la subclase ' constructor. Esto asegurará que si llama a cualquier método en la clase principal en su constructor, la clase principal ya se ha configurado correctamente.

Lo que está tratando de hacer, pasar argumentos al superconstructor es perfectamente legal, solo necesita construir esos argumentos en línea mientras lo está haciendo, o pasarlos a su constructor y luego pasarlos a super:

public MySubClassB extends MyClass {
        public MySubClassB(Object[] myArray) {
                super(myArray);
        }
}

Si el compilador no hizo cumplir esto, puede hacer esto:

public MySubClassB extends MyClass {
        public MySubClassB(Object[] myArray) {
                someMethodOnSuper(); //ERROR super not yet constructed
                super(myArray);
        }
}

En los casos en que un parent la clase tiene un constructor predeterminado, la llamada a super se inserta automáticamente por el compiler. Dado que cada clase en Java hereda de Object, el constructor de objetos debe llamarse de alguna manera y debe ejecutarse primero. La inserción automática de super () por parte del compilador lo permite. Al hacer que super aparezca primero, obliga a que los cuerpos del constructor se ejecuten en el orden correcto, que sería: Objeto -> Padre -> Niño -> Niño de niño -> SoOnSoForth

Encontré una forma de evitar esto encadenando constructores y métodos estáticos. Lo que quería hacer se parecía a esto:

public class Foo extends Baz {
  private final Bar myBar;

  public Foo(String arg1, String arg2) {
    // ...
    // ... Some other stuff needed to construct a 'Bar'...
    // ...
    final Bar b = new Bar(arg1, arg2);
    super(b.baz()):
    myBar = b;
  }
}

Básicamente, construya un objeto basado en parámetros de constructor, almacene el objeto en un miembro y también pase el resultado de un método en ese objeto al constructor de super. Hacer que el miembro sea definitivo también fue razonablemente importante ya que la naturaleza de la clase es que es inmutable. Tenga en cuenta que, como sucede, la construcción de Bar en realidad requiere algunos objetos intermedios, por lo que no se puede reducir a una sola línea en mi caso de uso real.

Terminé haciéndolo funcionar de esta manera:

public class Foo extends Baz {
  private final Bar myBar;

  private static Bar makeBar(String arg1,  String arg2) {
    // My more complicated setup routine to actually make 'Bar' goes here...
    return new Bar(arg1, arg2);
  }

  public Foo(String arg1, String arg2) {
    this(makeBar(arg1, arg2));
  }

  private Foo(Bar bar) {
    super(bar.baz());
    myBar = bar;
  }
}

Código legal, y cumple la tarea de ejecutar múltiples declaraciones antes de llamar al superconstructor.

Porque la JLS lo dice. ¿Se podría cambiar el JLS de manera compatible para permitirlo? Sip.

Sin embargo, complicaría la especificación del idioma, que ya es lo suficientemente complicada. No sería algo muy útil de hacer y hay formas de evitarlo (llame a otro constructor con el resultado de un método estático o expresión lambda this(fn()) - el método se llama antes que el otro constructor y, por lo tanto, también el superconstructor). Entonces, la relación potencia / peso de hacer el cambio es desfavorable.

Tenga en cuenta que esta regla por sí sola no evita el uso de campos antes de que la superclase haya completado la construcción.

Considere estos ejemplos ilegales.

super(this.x = 5);

super(this.fn());

super(fn());

super(x);

super(this instanceof SubClass);
// this.getClass() would be /really/ useful sometimes.

Este ejemplo es legal, pero "incorrecto".

class MyBase {
    MyBase() {
        fn();
    }
    abstract void fn();
}
class MyDerived extends MyBase {
    void fn() {
       // ???
    }
}

En el ejemplo anterior, si MyDerived.fn argumentos requeridos de la MyDerived constructor tendrían que ser reducidos con un ThreadLocal. ; (

Por cierto, desde Java 1.4, el campo sintético que contiene el exterior this se asigna antes de que se llame al superconstructor de clases internas. Esto provocó peculiar NullPointerException eventos en código compilado para apuntar a versiones anteriores.

Tenga en cuenta también que, en presencia de una publicación insegura, la construcción puede verse reordenada por otros hilos, a menos que se tomen precauciones.

Edición de marzo de 2018: En mensaje Registros: construcción y validación Oracle sugiere que se elimine esta restricción (pero a diferencia de C #, this se mostrarán definitivamente no asignado (DU) antes del encadenamiento del constructor).

Históricamente, este () o super () debe ser el primero en un constructor. Esta restricción nunca fue popular y se percibió como arbitraria. Hubo una serie de razones sutiles, incluida la verificación de invocarespecial, que contribuyeron a esta restricción. A lo largo de los años, los hemos abordado a nivel de VM, hasta el punto en que resulta práctico considerar eliminar esta restricción, no solo para los registros, sino para todos los constructores.

Simplemente porque esta es la filosofía de la herencia. Y de acuerdo con la especificación del lenguaje Java, así es como se define el cuerpo del constructor:

ConstructorBody: {ExplicitConstructorInvocation_optar    declaraciones de bloque_optar }

La primera declaración de un cuerpo de constructor puede ser

• una invocación explícita de otro constructor de la misma clase (utilizando la palabra clave "this"); o
• una invocación explícita de la superclase directa (mediante el uso de la palabra clave "super")

Si el cuerpo de un constructor no comienza con una invocación explícita del constructor y el constructor que se declara no es parte de la clase primordial Object, entonces el cuerpo del constructor comienza implícitamente con una invocación de constructor de superclase "super ();", una invocación del constructor de su superclase directa que no acepta argumentos. Y así sucesivamente ... habrá toda una cadena de constructores llamados hasta el constructor de Object; "Todas las clases de la plataforma Java son descendientes de objetos". Esta cosa se llama "Encadenamiento de constructores".

Ahora, ¿por qué es esto?
Y la razón por la que Java definió el ConstructorBody de esta manera, es que necesitaban mantener la jerarquía del objeto. Recuerde la definición de herencia; Está ampliando una clase. Dicho esto, no se puede extender algo que no existe. La base (la superclase) debe crearse primero, luego puede derivarla (la subclase). Por eso las llamaron clases para padres e hijos; no puedes tener un hijo sin un padre.

A nivel técnico, una subclase hereda todos los miembros (campos, métodos, clases anidadas) de su padre. Y dado que los constructores NO son miembros (no pertenecen a objetos. Son responsables de crear objetos) por lo que NO son heredados por subclases, pero pueden ser invocados. Y desde en el momento de la creación del objeto, solo se ejecuta UN constructor. Entonces, ¿cómo garantizamos la creación de la superclase cuando crea el objeto de subclase? De ahí el concepto de "encadenamiento de constructores"; por lo que tenemos la capacidad de invocar a otros constructores (es decir, super) desde dentro del constructor actual. Y Java requería que esta invocación fuera la PRIMERA línea en el constructor de subclase para mantener la jerarquía y garantizarla. Asumen que si no crea explícitamente el objeto padre PRIMERO (como si lo hubiera olvidado), lo harán implícitamente por usted.

Esta comprobación se realiza durante la compilación. Pero no estoy seguro de lo que sucedería en tiempo de ejecución, qué tipo de error de tiempo de ejecución obtendríamos, SI Java no arroja un error de compilación cuando intentamos explícitamente ejecutar un constructor base desde dentro del constructor de una subclase en medio de su cuerpo y no desde la primera línea ...

Estoy bastante seguro (los que están familiarizados con la especificación de Java intervienen) de que es para evitar que (a) se le permita usar un objeto parcialmente construido, y (b), forzar al constructor de la clase principal a construir en un "nuevo "objeto.

Algunos ejemplos de algo "malo" serían:

class Thing
{
    final int x;
    Thing(int x) { this.x = x; }
}

class Bad1 extends Thing
{
    final int z;
    Bad1(int x, int y)
    {
        this.z = this.x + this.y; // WHOOPS! x hasn't been set yet
        super(x);
    }        
}

class Bad2 extends Thing
{
    final int y;
    Bad2(int x, int y)
    {
        this.x = 33;
        this.y = y; 
        super(x); // WHOOPS! x is supposed to be final
    }        
}

Usted preguntó por qué, y las otras respuestas, imo, realmente no dicen por qué está bien llamar al constructor de su super, pero solo si es la primera línea. La razón es que no eres realmente llamar el constructor. En C ++, la sintaxis equivalente es

MySubClass: MyClass {

public:

 MySubClass(int a, int b): MyClass(a+b)
 {
 }

};

Cuando ve la cláusula inicializadora por sí sola así, antes de la llave abierta, sabe que es especial. Se ejecuta antes de que se ejecute el resto del constructor y, de hecho, antes de que se inicialice cualquiera de las variables miembro. No es tan diferente para Java. Hay una manera de hacer que se ejecute algún código (otros constructores) antes de que el constructor realmente comience, antes de que se inicialice cualquier miembro de la subclase. Y de esa forma es poner la "llamada" (p. Ej. super) en la primera línea. (De manera que super or this es un poco antes de la primera llave abierta, aunque la escriba después, porque se ejecutará antes de llegar al punto en que todo esté completamente construido). Cualquier otro código después de la llave abierta (como int c = a + b;) hace que el compilador diga "oh, ok, no hay otros constructores, entonces podemos inicializar todo". Entonces se ejecuta e inicializa su superclase y sus miembros y todo eso y luego comienza a ejecutar el código después de la llave abierta.

Si, unas líneas más tarde, encuentra algún código que dice "oh, sí, cuando estás construyendo este objeto, aquí están los parámetros que quiero que pases al constructor de la clase base", es demasiado tarde y no ningún sentido. Entonces obtienes un error del compilador.

Por lo tanto, no le impide ejecutar la lógica antes de la llamada a super. Simplemente le impide ejecutar la lógica que no puede encajar en una sola expresión.

En realidad, puede ejecutar la lógica con varias expresiones, solo tiene que envolver su código en una función estática y llamarlo en la declaración super.

Usando tu ejemplo:

public class MySubClassC extends MyClass {
    public MySubClassC(Object item) {
        // Create a list that contains the item, and pass the list to super
        super(createList(item));  // OK
    }

    private static List createList(item) {
        List list = new ArrayList();
        list.add(item);
        return list;
    }
}

Estoy totalmente de acuerdo, las restricciones son demasiado fuertes. No siempre es posible utilizar un método auxiliar estático (como sugirió Tom Hawtin - tackline) o introducir todos los "cálculos pre-super ()" en una sola expresión en el parámetro, por ejemplo:

class Sup {
    public Sup(final int x_) { 
        //cheap constructor 
    }
    public Sup(final Sup sup_) { 
        //expensive copy constructor 
    }
}

class Sub extends Sup {
    private int x;
    public Sub(final Sub aSub) {
        /* for aSub with aSub.x == 0, 
         * the expensive copy constructor is unnecessary:
         */

         /* if (aSub.x == 0) { 
          *    super(0);
          * } else {
          *    super(aSub);
          * } 
          * above gives error since if-construct before super() is not allowed.
          */

        /* super((aSub.x == 0) ? 0 : aSub); 
         * above gives error since the ?-operator's type is Object
         */

        super(aSub); // much slower :(  

        // further initialization of aSub
    }
}

Usar una excepción de "objeto aún no construido", como sugirió Carson Myers, ayudaría, pero verificar esto durante la construcción de cada objeto ralentizaría la ejecución. Yo preferiría un compilador de Java que haga una mejor diferenciación (en lugar de prohibir inconsecuentemente una declaración if pero permitir el operador? Dentro del parámetro), incluso si esto complica la especificación del lenguaje.

Puede usar bloques inicializadores anónimos para inicializar campos en el niño antes de llamar a su constructor. Este ejemplo demostrará:

public class Test {
    public static void main(String[] args) {
        new Child();
    }
}

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

class Child extends Parent {

    {
        System.out.println("In initializer");
    }

    public Child() {
        super();
        System.out.println("In child");
    }
}

Esto dará como resultado:

En padre
En inicializador
En niño

Encontré un woraround.

Esto no compilará:

public class MySubClass extends MyClass {
    public MySubClass(int a, int b) {
        int c = a + b;
        super(c);  // COMPILE ERROR
        doSomething(c);
        doSomething2(a);
        doSomething3(b);
    }
}

Esto funciona :

public class MySubClass extends MyClass {
    public MySubClass(int a, int b) {
        this(a + b);
        doSomething2(a);
        doSomething3(b);
    }

    private MySubClass(int c) {
        super(c);
        doSomething(c);
    }
}

Supongo que hicieron esto para facilitar la vida de las personas que escriben herramientas que procesan código Java y, en menor grado, también de las personas que leen código Java.

Si permites que el super() or this() llame para moverse, hay más variaciones para verificar. Por ejemplo, si mueve el super() or this() llamar a un condicional if() podría tener que ser lo suficientemente inteligente como para insertar un implícito super() en el else. Es posible que deba saber cómo informar un error si llama super() dos veces, o usar super() y this() juntos. Es posible que deba rechazar las llamadas a métodos en el receptor hasta super() or this() se llama y averiguar cuándo se vuelve complicado.

Hacer que todos hicieran este trabajo adicional probablemente parecía un mayor costo que beneficio.

¿Puede dar un ejemplo de código en el que, si el compilador no tuviera esta restricción, sucedería algo malo?

class Good {
    int essential1;
    int essential2;

    Good(int n) {
        if (n > 100)
            throw new IllegalArgumentException("n is too large!");
        essential1 = 1 / n;
        essential2 = n + 2;
    }
}

class Bad extends Good {
    Bad(int n) {
        try {
            super(n);
        } catch (Exception e) {
            // Exception is ignored
        }
    }

    public static void main(String[] args) {
        Bad b = new Bad(0);
//        b = new Bad(101);
        System.out.println(b.essential1 + b.essential2);
    }
}

Una excepción durante la construcción casi siempre indica que el objeto que se está construyendo no se pudo inicializar correctamente, ahora está en mal estado, es inutilizable y debe ser recolectado como basura. Sin embargo, un constructor de una subclase tiene la capacidad de ignorar una excepción ocurrida en una de sus superclases y devolver un objeto parcialmente inicializado. En el ejemplo anterior, si el argumento dado a new Bad() es 0 o mayor que 100, entonces ninguno essential1 ni essential2 están correctamente inicializados.

Puede decir que ignorar las excepciones siempre es una mala idea. Bien, aquí hay otro ejemplo:

class Bad extends Good {
    Bad(int n) {
        for (int i = 0; i < n; i++)
            super(i);
    }
}

Gracioso, ¿no es así? ¿Cuántos objetos estamos creando en este ejemplo? ¿Uno? ¿Dos? O tal vez nada ...

Permitiendo llamar super() or this() en medio de un constructor abriría una caja de Pandora de atroces constructores.

Por otro lado, entiendo la necesidad frecuente de incluir alguna parte estática antes de una llamada a super() or this(). Este podría ser cualquier código que no dependa de this referencia (que, de hecho, ya existe al principio de un constructor, pero no se puede utilizar de forma ordenada hasta super() or this() devoluciones) y necesario para realizar dicha llamada. Además, como en cualquier método, existe la posibilidad de que algunas variables locales creadas antes de la llamada a super() or this() será necesario después de él.

En tales casos, tiene las siguientes oportunidades:

1. Utilice el patrón presentado en esta respuesta, lo que permite eludir la restricción.
2. Espere a que el equipo de Java permita lasuper() y prethis() código. Puede hacerse imponiendo una restricción sobre dónde super() or this() puede ocurrir en un constructor. En realidad, incluso el compilador actual es capaz de distinguir casos buenos y malos (o potencialmente malos) con el grado suficiente para permitir de forma segura la adición de código estático al comienzo de un constructor. De hecho, suponga que super() y this() retorno this referencia y, a su vez, su constructor tiene

return this;

al final. Así como el compilador rechaza el código

public int get() {
    int x;
    for (int i = 0; i < 10; i++)
        x = i;
    return x;
}

public int get(int y) {
    int x;
    if (y > 0)
        x = y;
    return x;
}

public int get(boolean b) {
    int x;
    try {
        x = 1;
    } catch (Exception e) {
    }
    return x;
}

con el error "es posible que la variable x no se haya inicializado", podría hacerlo en this variable, haciendo sus comprobaciones en ella como en cualquier otra variable local. La única diferencia es this no se puede asignar por ningún otro medio que no sea super() or this() llamar (y, como de costumbre, si no hay tal llamada en un constructor, super() se inserta implícitamente por el compilador al principio) y es posible que no se asigne dos veces. En caso de duda (como en la primera get(), Donde x en realidad siempre está asignado), el compilador podría devolver un error. Eso sería mejor que simplemente devolver un error en cualquier constructor donde haya algo excepto un comentario antes super() or this().

Tiene sentido que los constructores completen su ejecución en orden de derivación. Debido a que una superclase no tiene conocimiento de ninguna subclase, cualquier inicialización que necesite realizar es independiente y posiblemente un requisito previo de cualquier inicialización realizada por la subclase. Por lo tanto, primero debe completar su ejecución.

Una simple demostración:

class A {
    A() {
        System.out.println("Inside A's constructor.");
    }
}

class B extends A {
    B() {
        System.out.println("Inside B's constructor.");
    }
}

class C extends B {
    C() {
        System.out.println("Inside C's constructor.");
    }
}

class CallingCons {
    public static void main(String args[]) {
        C c = new C();
    }
}

El resultado de este programa es:

Inside A's constructor
Inside B's constructor
Inside C's constructor

Sé que llego un poco tarde a la fiesta, pero he usado este truco un par de veces (y sé que es un poco inusual):

Creo una interfaz genérica InfoRunnable<T> con un método:

public T run(Object... args);

Y si necesito hacer algo antes de pasarlo al constructor, simplemente hago esto:

super(new InfoRunnable<ThingToPass>() {
    public ThingToPass run(Object... args) {
        /* do your things here */
    }
}.run(/* args here */));

En realidad, super() es la primera declaración de un constructor porque para asegurarse de que su superclase esté completamente formada antes de que se construya la subclase. Incluso si no tienes super() en su primera declaración, el compilador lo agregará por usted.

Eso es porque su constructor depende de otros constructores. Para que su constructor funcione correctamente, es necesario que otro constructor funcione correctamente, lo cual es dependiente. Es por eso que es necesario verificar primero los constructores dependientes que llamaron por this () o super () en su constructor. Si otros constructores que llamaron por this () o super () tienen un problema, entonces qué sentido tiene ejecutar otras declaraciones porque todas fallarán si falla el constructor llamado.

Tldr:

Las otras respuestas han abordado el "por qué" de la pregunta. Proporcionaré un corte alrededor de esta limitación:

La idea básica es secuestrar al super declaración con sus declaraciones incrustadas. Esto se puede hacer disfrazando sus declaraciones como expresiones.

Tsdr:

Considere que queremos hacer Statement1() a Statement9() antes de que llamemos super():

public class Child extends Parent {
    public Child(T1 _1, T2 _2, T3 _3) {
        Statement_1();
        Statement_2();
        Statement_3(); // and etc...
        Statement_9();
        super(_1, _2, _3); // compiler rejects because this is not the first line
    }
}

El compilador, por supuesto, rechazará nuestro código. Entonces, en cambio, podemos hacer esto:

// This compiles fine:

public class Child extends Parent {
    public Child(T1 _1, T2 _2, T3 _3) {
        super(F(_1), _2, _3);
    }

    public static T1 F(T1 _1) {
        Statement_1();
        Statement_2();
        Statement_3(); // and etc...
        Statement_9();
        return _1;
    }
}

La única limitación es que el la clase padre debe tener un constructor que tome al menos un argumento para que podamos colarse en nuestra declaración como expresión.

Aquí hay un ejemplo más elaborado:

public class Child extends Parent {
    public Child(int i, String s, T1 t1) {
        i = i * 10 - 123;
        if (s.length() > i) {
            s = "This is substr s: " + s.substring(0, 5);
        } else {
            s = "Asdfg";
        }
        t1.Set(i);
        T2 t2 = t1.Get();
        t2.F();
        Object obj = Static_Class.A_Static_Method(i, s, t1);
        super(obj, i, "some argument", s, t1, t2); // compiler rejects because this is not the first line
    }
}

Rediseñado en:

// This compiles fine:

public class Child extends Parent {
    public Child(int i, String s, T1 t1) {
        super(Arg1(i, s, t1), Arg2(i), "some argument", Arg4(i, s), t1, Arg6(i, t1));
    }

    private static Object Arg1(int i, String s, T1 t1) {
        i = Arg2(i);
        s = Arg4(s);
        return Static_Class.A_Static_Method(i, s, t1);
    }

    private static int Arg2(int i) {
        i = i * 10 - 123;
        return i;
    }

    private static String Arg4(int i, String s) {
        i = Arg2(i);
        if (s.length() > i) {
            s = "This is sub s: " + s.substring(0, 5);
        } else {
            s = "Asdfg";
        }
        return s;
    }

    private static T2 Arg6(int i, T1 t1) {
        i = Arg2(i);
        t1.Set(i);
        T2 t2 = t1.Get();
        t2.F();
        return t2;
    }
}

De hecho, los compiladores podrían habernos automatizado este proceso. Simplemente habían elegido no hacerlo.

Antes de que pueda construir un objeto hijo, debe crear su objeto padre. Como sabes cuando escribes una clase como esta:

public MyClass {
        public MyClass(String someArg) {
                System.out.println(someArg);
        }
}

pasa al siguiente (extender y super simplemente están ocultos):

public MyClass extends Object{
        public MyClass(String someArg) {
                super();
                System.out.println(someArg);
        }
}

Primero creamos un Object y luego extender este objeto a MyClass. No podemos crear MyClass antes de Object. La regla simple es que se debe llamar al constructor principal antes que al constructor secundario. Pero sabemos que las clases pueden tener más de un constructor. Java nos permite elegir un constructor que se llamará (o será super() or super(yourArgs...)). Entonces, cuando escribes super(yourArgs...) redefine el constructor que será llamado para crear un objeto padre. No puedes ejecutar otros métodos antes super() porque el objeto aún no existe (pero después super() se creará un objeto y podrá hacer lo que quiera).

Entonces, ¿por qué entonces no podemos ejecutar this() después de cualquier método? Como sabes this() es el constructor de la clase actual. También podemos tener diferentes números de constructores en nuestra clase y llamarlos como this() or this(yourArgs...). Como dije, cada constructor tiene un método oculto. super(). Cuando escribimos nuestra costumbre super(yourArgs...) nosotros quitamos super() a super(yourArgs...). También cuando definimos this() or this(yourArgs...) también eliminamos nuestro super() en el constructor actual porque si super() estaban con this() en el mismo método, crearía más de un objeto principal. Por eso se imponen las mismas reglas para this() método. Simplemente retransmite la creación del objeto padre a otro constructor hijo y ese constructor llama super() constructor para la creación de padres. Entonces, el código será así de hecho:

public MyClass extends Object{
        public MyClass(int a) {
                super();
                System.out.println(a);
        }
        public MyClass(int a, int b) {
                this(a);
                System.out.println(b);
        }
}

Como dicen otros, puede ejecutar código como este:

this(a+b);

también puedes ejecutar código como este:

public MyClass(int a, SomeObject someObject) {
    this(someObject.add(a+5));
}

Pero no puede ejecutar código como este porque su método aún no existe:

public MyClass extends Object{
    public MyClass(int a) {

    }
    public MyClass(int a, int b) {
        this(add(a, b));
    }
    public int add(int a, int b){
        return a+b;
    }
}

También estás obligado a tener super() constructor en tu cadena de this() métodos. No puede tener una creación de objeto como esta:

public MyClass{
        public MyClass(int a) {
                this(a, 5);
        }
        public MyClass(int a, int b) {
                this(a);
        }
}

class C
{
    int y,z;

    C()
    {
        y=10;
    }

    C(int x)
    {
        C();
        z=x+y;
        System.out.println(z);
    }
}

class A
{
    public static void main(String a[])
    {
        new C(10);
    }
}

Vea el ejemplo si estamos llamando al constructor C(int x) entonces el valor de z depende de y si no llamamos C() en la primera línea, entonces será el problema de z. z no podría obtener el valor correcto.

La pregunta de por qué Java hace esto ya ha sido respondida, pero como me topé con esta pregunta con la esperanza de encontrar una mejor alternativa a la de una sola línea, por la presente compartiré mi solución alternativa:

public class SomethingComplicated extends SomethingComplicatedParent {

    private interface Lambda<T> {
        public T run();
    }

    public SomethingComplicated(Settings settings) {
        super(((Lambda<Settings>) () -> {

            // My modification code,
            settings.setting1 = settings.setting2;
            return settings;
        }).run());
    }
}

Llamar a una función estática debería funcionar mejor, pero lo usaría si insisto en tener el código "dentro" del constructor, o si tengo que alterar múltiples parámetros y encontrar que definir muchos métodos estáticos es malo para la legibilidad.

El objetivo principal de agregar super () en los constructores de subclase es que el trabajo principal del compilador es hacer una conexión directa o indirecta de todas las clases con la clase Object, por eso el compilador verifica si hemos proporcionado el super (parametrizado), el compilador no asume ninguna responsabilidad. de modo que todo el miembro de la instancia se inicialice de Object a las subclases.