Chiamare super ()

Quando chiami super () in Java? Lo vedo in alcuni costruttori della class derivata, ma non sono i costruttori per ciascuna delle classi genitore chiamata automaticamente? Perché dovresti usare super?

Se fornisci una class come questa:

public class Foo { } 

o questo:

 public class Foo() { public Foo() { } } 

il compilatore genererà il codice per questo:

 public class Foo() { public Foo() { super(); } } 

Quindi, in senso stretto, la chiamata a “super ()” è sempre lì.

In pratica dovresti chiamare solo “super (…)” dove ci sono parametri che vuoi passare al costruttore genitore.

Non è sbagliato chiamare “super ()” (senza parametri) ma la gente riderà di te 🙂

Dovresti usare super() in un caso come questo:

 public class Base { public Base(int foo) { } } public class Subclass extends Base { public Subclass() { super(15); } } 

Questo è un esempio molto forzato, ma l’unica volta che è necessario chiamare super() è se si sta ereditando da una class che non ha fornito un costruttore predefinito, senza parametri. In questo caso è necessario chiamare esplicitamente super() dal costruttore della sottoclass, passando i parametri necessari per soddisfare il costruttore della class base. Inoltre, la chiamata a super() deve essere la prima riga del costruttore della class ereditata.

Non è necessario chiamare super ().

Dall’accesso ai membri Superclass :

Con super (), viene chiamato il costruttore senza argomenti della superclass. Con super (lista parametri), viene chiamato il costruttore della superclass con una lista di parametri corrispondente.

Nota: se un costruttore non richiama esplicitamente un costruttore di superclass, il compilatore Java inserisce automaticamente una chiamata al costruttore no-argument della superclass. Se la super class non ha un costruttore senza argomenti, si otterrà un errore in fase di compilazione. L’object ha un tale costruttore, quindi se Object è l’unica superclass, non ci sono problemi.

Se non si riesce a chiamare super in un costruttore, il compilatore aggiungerà una super-chiamata senza argomento come costruttore genitore per la prima riga del corpo del costruttore.

Così come nel codice precedentemente pubblicato

 public class Foo { } 

o

 public class Foo { public Foo() { } } 

il compilatore genererà un codice che si allinea con le regole di Java. Tutti gli oggetti sono sottoclassi di java.lang.Object, quindi il compilatore lo compilerà come se fosse scritto

 // All classs extend Object. This is Java, after all. public class Foo extends java.lang.Object { public Foo() { // When constructing Foo, we must call the Object() constructor or risk // some parts of Foo being undefined, like getClass() or toString(). super() } } 

Ma se la super class non ha un costruttore che corrisponda ai parametri, allora devi chiamare il costruttore di super classi appropriato non corrispondente.

 public class LightBlue extends java.awt.Color { public LightBlue() { // There is no Color() constructor, we must specify the suitable super class // constructor. We chose Color(int red, int green, int blue). super(172, 216, 230); } } 

Altre volte, forse c’è un costruttore che corrisponde alla firma del costruttore della sottoclass, ma per qualsiasi motivo, non si desidera passare i parametri direttamente al costruttore super-class.

 public class HSVColor extends Color { public HSVColor(int hue, int saturation, int value) { super(...code converting HSV to Red..., ...code converting HSV to Green..., ...code converting HSV to Blue); } } 

Se si trascura di specificare esplicitamente il costruttore di super classi, il compilatore aggiunge al costruttore di classi super no-arg predefinito. Tuttavia, se il costruttore non esiste, il compilatore non compilerà la class, poiché non è chiaro quale dei costruttori esposti sia quello corretto da chiamare.

È una considerazione di stile, ma puoi decidere di includere sempre la chiamata super (). Se si sceglie di farlo, sarà perché si desidera ricordare al lettore che gli oggetti della class base devono essere costruiti come parte dell’object sub class e si desidera rendere esplicito il particolare costruttore di super classi. Tradizionalmente, una chiamata super () sempre inclusa è piuttosto strana, dal momento che tradizionalmente il codice viene digitato solo se si differenzia dal comportamento “predefinito”.

Come è stato detto, se il costruttore non chiama esplicitamente super () con o senza qualche argomento, java chiamerà automaticamente il costruttore predefinito della superclass.

Tuttavia, chiamare esplicitamente super () è proprio questo: esplicito. Se sai che il costruttore della superclass fa qualcosa di significativo, è un utile promemoria per chi sta mantenendo il tuo codice che super () viene chiamato per primo (e potrebbe avere effetti collaterali). Questo potrebbe anche essere un punto utile per inserire un punto di interruzione durante il debug.

Quando hai una class che estende un’altra class e la class padre non ha un costruttore predefinito, devi usare super () nel costruttore di Son per chiamare il costruttore nella class padre con gli argomenti appropriati come questo:

 class A { int a; A(int value) { this.a=value; System.out.println("A Constructor " + a ); } } class B extends A { int b; B() { super(5); this.b=10; System.out.println("B Constructor " + b); } } 

devi sapere che non puoi usare “super” con “this” se vuoi chiamare un altro costruttore nel calss usando “this”.

Volevo fornire alcune informazioni che non sono state menzionate finora. Se si usa una chiamata a this(...) in un costruttore, non si può avere una chiamata a super(...); Ciò include anche l’inserimento automatico di Java della chiamata senza parametri a super();

L’esempio seguente illustra questo punto, inclusi i commenti esplicativi:

 public class B extends A { private int x; public B() { // Java doesn't call super(); here, because // of the call to this(...); below. // You can't call super(...) here either, // for the same reason. this(42); // Calls public B(int x) below. } public B(int x) { // Java does call super(); here. // You can call super(...) here, if you want/need to. // The net result of calling new B() above is that // super(...) for class A only gets called once. this.x = x; } } 

super () è implicito quando nessun altro costruttore di class / superclass viene chiamato.

È ansible chiamare super () con i parametri se si desidera chiamare un costruttore non predefinito della superclass o se la superclass non ha un costruttore predefinito. Il compilatore può solo inserire il costruttore predefinito, senza argomenti super ().

Perché il costruttore della super class non viene chiamato automaticamente. Ad esempio, potrebbero esserci diversi costruttori, alcuni dei quali richiedono parametri aggiuntivi. Quindi non sempre hai un’istruzione super vuota (), ma qualcosa del genere:

 public class DerivedClass extends SomeOtherClass { private String anotherParameter; public DerivedClass(int parameterA, String parameterB, String anotherParameter) { super(parameterA, parameterB); this.anotherParameter = anotherParameter; } } 

Edit: Ovviamente ho dimenticato di dire (o la mia scelta di parole semplicemente non era buona, ma non sono madrelingua, mi dispiace per questo) che se la super-class non prende alcun parametro, la chiamata a super () sarà fatto per te da java / il compilatore. (Ora che rileggo la mia risposta, posso vedere che sembra davvero che tu debba sempre chiamare super ()).

Sebbene super() non funzioni in modo funzionale per il compilatore (il costruttore di default della superclass viene chiamato automaticamente), sicuramente fa molto per me. Mi dice: “Non rimuovere il costruttore vuoto, è lì per un motivo”.

Un esempio perfetto è dove crei bean gestiti Spring o quadro JPA e hai creato un costruttore parametrizzato.

 @Entity public class Portfolio { ... public Portfolio() { super(); // This says to me: DON'T DELETE! } /** * Because there is now a parameterised constructor (me), * the default constructor no longer exists. This means * that for this example, you need an empty constructor in place (above) **/ public Portfolio(String name) { this.name = name; } } 

Super viene chiamato quando vogliamo ereditare alcuni parametri dalla class genitore. Non è obbligatorio in quanto il compilatore chiama sempre il costruttore predefinito. Se si desidera ereditare un costruttore con alcuni parametri, è necessario chiamare il super. Quindi puoi usarlo.