Aflați utilizarea acestor () și (super) în lanțul constructorului Java

Înlănțuirea constructorului în Java este pur și simplu actul unui constructor de a chema un alt constructor prin moștenire. Acest lucru se întâmplă implicit atunci când este construită o subclasă: prima sa sarcină este să numească metoda constructorului părintească. Programatorii pot, de asemenea, să apeleze explicit la un alt constructor folosind cuvintele cheie acest() sau super(). acest() Cuvântul cheie apelează un alt constructor supraîncărcat din aceeași clasă; super() Cuvântul cheie apelează un constructor implicit într-o superclasă.

Lanțuri constructive implicite

Înlănțuirea constructorului apare prin utilizarea moștenirii. Prima sarcină a unei metode de constructor din subclase este aceea de a numi metoda constructorului superclasei sale. Acest lucru asigură că crearea obiectului subclase începe cu inițializarea claselor de deasupra acestuia în lanțul de moștenire.

Poate exista un număr de clase dintr-un lanț de moștenire. Fiecare metodă de constructor apelează lanțul până la atingerea și inițializarea clasei din partea de sus. Apoi, fiecare clasă ulterioară de mai jos este inițializată pe măsură ce lanțul se reîntoarce în subclasa inițială. Acest proces se numește înlănțuirea constructorului.

Rețineți că:

• Acest apel implicit către superclase este același ca și în cazul în care subclasa ar fi inclus super() cuvânt cheie, adică. super() este implicit aici.
• Dacă un constructor fără args nu este inclus în clasă, Java creează unul din culise și îl invocă. Aceasta înseamnă că, dacă singurul dvs. constructor ia un argument, trebuie explicit folosește o acest() sau super() cuvânt cheie pentru a-l invoca (vezi mai jos).

Luați în considerare acest superclase Animal extins de mamifere:

clasa Animal 
// constructor
Animal()

 System.out.println ("Suntem în clasa constructorului animalelor.");

Clasa Mamiferul extinde Animal 
//constructor
Mamifer()

 System.out.println ("Suntem în clasa constructorului Mammal.");

Acum, haideți să instiămăm clasa Mamifer:

public class ChainingConstructors 

 / **
* @param args
* /
public static void main (String [] args) 
Mamifer m = mamifer nou ();

Când rulează programul de mai sus, Java declanșează implicit un apel către constructorul de superclase Animal, apoi către constructorul clasei. Prin urmare, rezultatul va fi:

Suntem în clasa constructorului Animal
Suntem în clasa constructorului Mamiferei

Înlănțuire constructivă explicită folosind acest () sau super ()

Utilizarea explicită a acest() sau super() cuvintele cheie vă permite să apelați un constructor implicit.

• Pentru a apela un constructor implicit non-args sau un constructor supraîncărcat din cadrul aceleiași clase, utilizați butonul acest() cuvinte cheie. 
• Pentru a apela un constructor de superclase non-implicit dintr-o subclasă, utilizați super() cuvinte cheie. De exemplu, dacă superclasa are mai mulți constructori, o subclasă poate dori întotdeauna să apeleze la un constructor specific, mai degrabă decât implicit.

Rețineți că apelul către un alt constructor trebuie să fie prima declarație din constructor sau Java va arunca o eroare de compilare.

Luați în considerare codul de mai jos în care o nouă subclasă, Carnivore, moștenește de la clasa Mammal care moștenește de la clasa Animal și fiecare clasă are acum un constructor care ia un argument.

Iată superclasa Animal: 

clasa publică Animal
nume privat String;
public Animal (numele șirului) // constructor cu un argument

this.name = nume;
System.out.println ("Sunt executat primul.");

Rețineți că constructorul ia acum o Nume de tip Şir ca parametru și pe care corpul clasei apelează acest() pe constructor. Fără utilizarea explicită a acest nume, Java ar crea un constructor implicit, fără argumente, și l-ar invoca în schimb.

Iată subclasa Mamifer:

public class Mammal extinde Animal 
public Mammal (numele șirului)

super-(nume);
System.out.println ("Sunt executat al doilea");

Constructorul său ia și un argument și folosește super-(nume) să invoce un constructor specific în superclasa sa.

Iată un alt subclase Carnivore. Aceasta moștenește de la Mammal: 

public class Carnivore extinde Mammal 
public Carnivore (numele șirului)

super-(nume);
System.out.println ("Am fost executat ultima dată");

Când sunt rulate, aceste trei blocuri de cod ar imprima:

Sunt executat mai întâi.
Sunt executat al doilea.
Sunt executat ultimul.

A recapitula: Atunci când este creată o instanță a clasei Carnivore, prima acțiune a metodei sale de construcție este să apeleze la metoda constructorului Mamifer. De asemenea, prima acțiune a metodei constructorului Mamifer este de a numi metoda constructorului Animal. Un lanț de apeluri de metodă constructor se asigură că instanța obiectului Carnivore a inițializat corect toate clasele din lanțul său de moștenire.