perché questo() e super() non possono essere usati insieme in un costruttore?

Question

Perché non è possibile utilizzare entrambi this() e super() in un costruttore?

Qual è la ragione per incorporare una cosa del genere?

Answer 1

this(...) chiamerà un altro costruttore nella stessa classe, mentre super() chiamerà un super costruttore. Se non c'è super() in un costruttore il compilatore ne aggiungerà uno implicitamente.

Pertanto, se entrambi fossero consentiti, potrebbe essere necessario chiamare il costruttore super due volte.

Esempio (non cercare un senso nei parametri):

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(); // 
    } 
} 

Ora, se si chiama new B(5) i seguenti costruttori vengono richiamati:

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

Aggiornamento:

Se si fosse in grado di utilizzare this() e super() si potrebbe finire con som ething come questo:

(Attenzione: questo è destinato a mostrare cosa potrebbe andare male, se vi lasciate fare quello - che per fortuna non sei)

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

come si può vedete, vi imbatterete in un problema in cui il costruttore A(boolean) potrebbe essere invocato con parametri diversi e ora dovreste decidere in qualche modo quale dovrebbe essere usato. Inoltre gli altri costruttori (A() e B()) potrebbero contenere codice che ora potrebbe non essere richiamato correttamente (ad esempio fuori servizio ecc.) Poiché la chiamata a super(true) li aggirerebbe mentre this() non lo farebbe.

Answer 2

Entrambe this() e super() sono chiamate del costruttore e la chiamata del costruttore deve essere la prima (e solo la prima) chiamata in un costruttore. In caso contrario, il costruttore Object verrà chiamato più di una volta durante l'istanziazione di un singolo oggetto.

Answer 3

C'è una differenza tra super() e this().

super() - chiama il costruttore della classe base, mentre
this() - chiama costruttore della classe corrente.

Entrambe this() e super() sono chiamate del costruttore.
La chiamata del costruttore deve sempre essere la prima istruzione. Quindi non possiamo avere due dichiarazioni come prima affermazione, quindi possiamo chiamare super() o chiamare il costruttore this(), ma non entrambi.

Answer 4

Perché non ha senso. Un costruttore deve chiamare this() o super() (implicitamente o esplicitamente).this() chiama un altro costruttore che deve chiamare o this() o super() ecc. Come prima. Pertanto, un costruttore che ha chiamato sia this() sia super() chiamerebbe in tal caso super() due volte.

Answer 5

• usiamo questo() parola chiave nel costruttore concatenamento per accedere al costruttore della stessa classe
• usiamo super() parola chiave quando si vuole accedere al costruttore della classe padre immediato eredità.

E v'è una condizione sia che essi devono essere dichiarati nella prima riga del costruttore che si sta utilizzando. E questo è il motivo per cui non possiamo usare entrambi in un singolo costruttore perché puoi scrivere solo una cosa nella tua prima riga.

Answer 6

Confronta l'esempio sotto. La classe FirstChild imposta il nome della variabile di istanza in 2 costruttori, in quanto la chiamata del secondo costruttore dal primo viene esclusa dalla necessità di chiamare super().

Nella classe SecondChild è stato introdotto un terzo costruttore privato che accetta 2 parametri: il primo è passato a supper() e il secondo è stato utilizzato per impostare il nome. I primi 2 costruttori chiamano il terzo. Super() è chiamato esattamente una volta, anche la variabile di istanza è impostata solo in un costruttore. Il codice produce lo stesso risultato senza bisogno di chiamare super() e this() nello stesso costruttore.

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

perché se si utilizza this() e super() insieme in un costruttore darà errore di compilazione tempo. Perché this() e super() devono essere la prima istruzione eseguibile. Se scrivi this() prima di super() diventerai la seconda affermazione e viceversa. Ecco perché non possiamo usare insieme this() e super().

Answer 8

this() e super(), entrambi sono i costruttori, ecco perché deve essere la prima affermazione. Ma possiamo usare entrambi in un programma.

questo(): È utilizzato per chiamare, Default di classe o Costruttore parametrizzato.

super(): È utilizzato per chiamare, classe super/genitore immediata Costruttore predefinito o parametrizzato.

//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); 
    } 
}