Perché chiamare super() in un costruttore?

Question

Ho a che fare con una classe che estende JFrame.

Non è il mio codice e effettua una chiamata a super prima che inizi a costruire la GUI. Mi chiedo il motivo per cui questo è stato fatto da quando ho sempre avuto accesso ai metodi della superclasse senza dover chiamare super();

Answer 1

C'è una chiamata implicita a super() senza argomenti per tutte le classi che hanno un genitore - che è ogni classe definita dall'utente in Java - quindi chiamarla in modo esplicito di solito non è richiesta. Tuttavia, è possibile che utilizzi la chiamata allo super() con gli argomenti se il costruttore del genitore accetta i parametri e si desidera specificarli. Inoltre, se il costruttore del genitore accetta parametri e non ha un costruttore senza parametri predefinito, sarà necessario per chiamare super() con argomenti.

Un esempio, dove la chiamata esplicita a super() ti dà un certo controllo supplementare sopra il titolo del telaio:

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

Answer 2

Una chiamata al costruttore vuoto della classe genitore super() viene eseguita automaticamente quando non lo si fa da soli. Questa è la ragione per cui non hai mai dovuto farlo nel tuo codice. È stato fatto per te

Quando la tua superclasse non ha un costruttore no-arg, il compilatore richiederà di chiamare super con gli argomenti appropriati. Il compilatore farà in modo di istanziare correttamente la classe. Quindi non è qualcosa di cui ti devi preoccupare troppo.

Sia che chiami o meno super() nel tuo costruttore, ciò non influisce sulla tua capacità di chiamare i metodi della tua classe genitore.

Come nota a margine, alcuni dicono che è generalmente meglio effettuare quella chiamata manualmente per ragioni di chiarezza.

Answer 3

Chiama semplicemente il costruttore predefinito della superclasse.

Answer 4

Siamo in grado di accedere ai membri della superclasse con Super()

Se il metodo sovrascrive uno dei metodi della sua superclasse, puoi invocare il metodo sovrascritto attraverso l'uso della parola chiave super. Puoi anche usare super per fare riferimento a un campo nascosto (anche se i campi nascosti sono scoraggiati). Considerate questa classe, Superclass:

public class Superclass { 

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

// Ecco una sottoclasse, chiamato sottoclasse, che sostituisce 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();  
    } 
} 

All'interno sottoclasse, il semplice nome printMethod() si riferisce a quello dichiarato nella sottoclasse, che sovrascrive quello in Superclasse. Quindi, per fare riferimento a printMethod() ereditato da Superclasse, la sottoclasse deve usare un nome qualificato, usando super come mostrato.La compilazione e l'esecuzione di stampe sottoclasse il seguente:

Printed in Superclass. 
Printed in Subclass 

Answer 5

possiamo accedere a elementi di super classe utilizzando il metodo super-

Consideriamo abbiamo due classi, classe genitore e di classe del bambino, con diverse implementazioni di metodo foo. Ora in classe child se vogliamo chiamare il metodo foo della classe genitore, possiamo farlo con super.foo(); possiamo anche accedere agli elementi genitore con il metodo 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(); 
     } 
    }