¿por qué no pueden utilizarse ambos() y super() juntos en un constructor?

Question

¿Por qué no se pueden usar this() y super() juntos en un constructor?

¿Cuál es el motivo para incorporar tal cosa?

Answer 1

this(...) llamará a otro constructor en la misma clase, mientras que super() llamará a un super constructor. Si no hay super() en un constructor, el compilador agregará uno implícitamente.

Por lo tanto, si se permitieran ambos, podría terminar llamando al constructor super dos veces.

Ejemplo (no hay que buscar un sentido en los parámetros):

class A { 
    public A() { 
    this(false); 
    } 

    public A(boolean someFlag) { 
    } 
} 

class B extends A { 
    public B() { 
    super(); 
    } 

    public B(boolean someFlag) { 
    super(someFlag); 
    } 

    public B (int someNumber) { 
    this(); // 
    } 
} 

Ahora, si se llama a new B(5) los siguientes constructores se invocan:

 this(false); 
A() ---------------> A(false) 
^ 
| 
| super(); 
| 
|  this(); 
B() <--------------- B(5) <--- you start here 

actualización:

Si pudiera usar this() y super() podría terminar con som ething así:

(Atención: esto está destinado a mostrar lo que podía salir mal, si se dejen de hacer eso - que, afortunadamente, no está)

 this(false); 
A() ---------------> A(false) 
^     ^
|     | 
| super();   | super(true); <--- Problem: should the parameter be true or false? 
|     | 
|  this();  | 
B() <--------------- B(5) <--- you start here 

Como se puede mira, te toparías con un problema donde el constructor A(boolean) podría invocarse con diferentes parámetros y ahora tendrías que decidir de alguna manera cuál debería usarse. Además, los otros constructores (A() y B()) podrían contener código que ahora podría no llamarse correctamente (es decir, fuera de servicio, etc.) ya que la llamada a super(true) los eludiría, mientras que this() no lo haría.

Answer 2

Tanto this() como super() son llamadas de constructor, y la llamada de constructor debe ser la primera (y la primera) llamada en un constructor. De lo contrario, el constructor Object se invocará más de una vez al crear una instancia de un solo objeto.

Answer 3

Hay una diferencia entre super() y this().

super() - llama al constructor de la clase base, mientras que
this() - llama constructor de la clase actual.

Tanto this() como super() son llamadas de constructor.
La llamada de constructor siempre debe ser la primera instrucción. Por lo tanto, no podemos tener dos declaraciones como primera instrucción, por lo tanto, podemos llamar al super() o podemos llamar al this() desde el constructor, pero no a ambas.

Answer 4

Porque no tiene sentido. Un constructor debe llamar this() o super() (implícita o explícitamente).this() llama a otro constructor que tiene que llamar this() o super() etc. como antes. Un constructor que llamara tanto a this() como a super() llamaría finalmente al super() dos veces.

Answer 5

• utilizamos este() palabra clave en el constructor de encadenamiento para acceder al constructor de la misma clase
• utilizamos super() palabra clave cuando queremos acceder al constructor de la clase padre inmediato en herencia.

Y no es una condición en tanto que tienen que ser declarada en el primera línea del constructor que está utilizando. Y esa es la razón por la que no podemos usar ambos en un solo constructor porque puede escribir solo una cosa en su primera línea .

Answer 6

Comparar el ejemplo a continuación. Class FirstChild establece el nombre de la variable de instancia en 2 constructores ya que llamar al segundo constructor desde el primero se excluye por necesidad de llamar a super().

En la clase SecondChild se presenta el tercer constructor privado que toma 2 parámetros: el primero pasó a supper() y el segundo se usó para establecer el nombre. Los primeros 2 constructores están llamando al tercero. Super() se llama exactamente una vez, también la variable de instancia se establece solo en un constructor. El código produce el mismo resultado sin necesidad de llamar a super() y this() en el mismo constructor.

class FirstChild extends ConstructorTest{ 
    private String name = null; 
    public FirstChild(){ 
     super("super text 1"); 
     //this("Unknown"); //UNCOMMENTED DOES NOT COMPILE 
     name = "Unknown"; 
    } 
    public FirstChild(String name){ 
     super("super text 2"); 
     this.name = name; 
    } 
    public String getName(){ 
     return name; 
    } 
} 

class SecondChild extends ConstructorTest{ 
    private String name = null; 
    public SecondChild(){ 
     this("super text 1", "Unknown"); 
    } 
    public SecondChild(String name){ 
     this("super text 2", name); 
    } 
    private SecondChild(String superStr, String name) 
    { 
     super(superStr); 
     this.name = name; 
    } 
    public String getName(){ 
     return name; 
    } 
} 

public class ConstructorTest{ 
    public ConstructorTest(String str){ 
     System.out.println("ConstructorTest constructor called with parameter \"" + str + "\""); 
    } 
    public static void main(String... args) 
    { 
     System.out.println("Hello from main, FirstChild results:"); 
     FirstChild fc1 = new FirstChild(); 
     FirstChild fc2 = new FirstChild("John"); 
     System.out.println("   child fc1 name: " + fc1.getName()); 
     System.out.println("   child fc2 name: " + fc2.getName()); 
     System.out.println("Hello from main, SecondChild results:"); 
     SecondChild sc1 = new SecondChild(); 
     SecondChild sc2 = new SecondChild("John"); 
     System.out.println("   child sc1 name: " + sc1.getName()); 
     System.out.println("   child sc2 name: " + sc2.getName()); 
    } 
} 

Answer 7

Porque si utiliza this() y super() juntos en un constructor que dará a compilar error de tiempo. Porque this() y super() debe ser la primera instrucción ejecutable. Si escribe this() primero que super() se convertirá en la segunda instrucción y viceversa. Es por eso que no podemos usar this() y super() juntos.

Answer 8

this() y super(), ambos son los constructores por eso debe ser la primera declaración. Pero podemos usar ambos en un programa.

this(): Se utiliza para llamar, la misma clase Predeterminada o Constructor parametrizado.

super(): Se utiliza para llamar, inmediato super/parent class Predeterminado o constructor parametrizado.

//Super Class 
    public class SuperConstructor { 
    SuperConstructor(){ 
     this(10); 
     System.out.println("Super DC"); 
    } 

    SuperConstructor(int a){ 
     this(10,20); 
     System.out.println("Suer SPC with Iteger"); 
    } 

    SuperConstructor(int i,int j){ 
     System.out.println("Super with DPC with Iteger and Integer"); 
    } 
} 


//subclass 
    public class ThisConstructor extends SuperConstructor{ 
    ThisConstructor(){ 
     this(10,20); 
     System.out.println("Subcalss DC ");//DC Default Constructor 
    } 

    ThisConstructor(int i){ 
     super(i);  
     System.out.println("Subcalss SPC with Iteger");//SPC Single Parameterized Constructor 
    } 

    ThisConstructor(int i, String s){ 
     this(); 
     System.out.println("Subcalss DPC with Iteger and String");//DPC double Parameterized Constructor 
    } 

    ThisConstructor(int i,int age){ 
     super(i,age); 
     System.out.println("Subcalss DPC with Iteger and Integer"); 
    } 

    public static void main(String []k){ 
     System.out.println("=================Frist time Calling ==========================\n"); 
     ThisConstructor t = new ThisConstructor(1); 


     System.out.println("=================Second time Calling ==========================\n"); 
     ThisConstructor t1 = new ThisConstructor(1,2); 
    } 
}