Constructor Chaining în Java cu exemple și implementare

În Java, constructorii pot fi înțeleși ca blocuri de cod folosite pentru a inițializa obiecte nou create. Un constructor este similar cu metodele de instanță din Java. Cu toate acestea, există o diferență crucială între Constructori și metode în Java - în timp ce metodele au un tip de returnare, Constructorii nu au niciun tip de returnare specific. Programatorii se referă adesea la constructori ca pe un tip special de metodă în Java.

Constructorii din Java au același nume ca și clasa și arată astfel:

clasa publica myProgram{

//Acesta este constructorul

myProgram(){

}

..

}

Când un constructor este apelat din interiorul altui constructor, atunci are loc Constructor Chaining în Java. Cu toate acestea, înainte de a ne aprofunda mai mult în Constructor Chaining, să aruncăm mai întâi o privire rapidă asupra modului în care lucrează Constructorii în Java, împreună cu câteva exemple pentru a vă consolida înțelegerea.

Cum funcționează constructorii în Java?

Pentru a înțelege cum funcționează constructorii, să ne uităm la un exemplu. Să presupunem că avem o clasă numită myProgram. Acum, când creăm obiectul acestei clase, va trebui să scriem următoarea declarație:

myProgram obj = new myProgram()

După cum puteți vedea, cuvântul cheie nou folosit în exemplul de mai sus creează obiectul myProgram și invocă un constructor pentru a inițializa acest obiect nou creat.

Dacă acest lucru vă sună puțin confuz, nu vă îngrijorați. Să ne uităm la un program constructor simplu în Java pentru a înțelege mai bine funcționarea Constructorilor în Java.

Programul de bază constructor în Java

Uitați-vă la următoarea bucată de cod Java care utilizează constructori:

test de clasă publică{

Cartea cu șiruri;

//Constructor

Test(){

this.book = „A Catcher in the Rye”;

}

public static void main(String[] args) {

Test obj = new Test();

System.out.println(obj.book);

}

}

Ieșire:

A Catcher in the Rye

În programul de mai sus, am creat un obiect numit „obj” din clasa noastră Program. Apoi, am tipărit numele variabilei de instanță a acestui obiect nou creat. După cum puteți vedea din ieșire, ieșirea este aceeași cu valoarea transmisă la „book” în timpul inițializării Constructorului.

Ceea ce arată aceasta este că în momentul în care obiectul obj a fost creat, Constructorul a fost invocat automat. Aici, am folosit cuvântul cheie „acest” pentru a face referire la obiectul curent. Există și mai multe modalități de a face acest lucru, despre care vom vorbi mai târziu în articol, în timp ce discutăm despre Constructor Chaining.

Cu elementele de bază ale Constructorului în Java stabilite, să trecem la Constructor Chaining în Java și cum funcționează!

Înlănțuirea constructorilor într-o singură clasă

Darce este înlănțuirea constructorului în Java care implică o singură clasă?Apelarea unui constructor de la altul din aceeași clasă include înlănțuirea constructorului în cadrul acelei clase. Cuvântul cheie „acest” este folosit în sintaxă pentru înlănțuirea constructorului în cadrul aceleiași clase. Se face referire la instanța de clasă curentă când se folosește „aceasta”. Cel mai bine este să înțelegeți utilizareaînlănțuirii constructorului în Java cu un exemplu .

Înlănțuirea constructorilor din clasele de bază/părinte

O clasă în Java poate deriva dintr-o altă clasă; clasa derivată este denumită subclasă, iar clasa din care derivă este denumită superclasă. O subclasă poate avea propriii ei constructori și îi poate invoca pe cei ai superclasei sale.

Un constructor de superclasă folosește termenul super(), urmat de intrările necesare. Cuvântul cheie super() trebuie să fie întotdeauna prezent în prima linie a constructorului subclaselor.

Apel de la un constructor diferit, un constructor

Folosind cuvântul cheie this(), un constructor în Java poate apela un alt constructor din aceeași clasă. Primul cuvânt cheie din constructor trebuie să fie întotdeauna cuvântul cheie this(), care poate fi folosit doar pentru a apela un alt constructor de același tip.

Constructor de superclasă de telefon

Cuvântul cheie super() din Java permite constructorilor de subclase să apeleze constructorul superclasei. Cuvântul cheie super(), care poate fi folosit doar pentru a apela constructorul superclasei subclasei, trebuie să fie întotdeauna prima linie a constructorului subclasei.

Programele Java se pot comporta diferit dacă constructorii sunt aranjați într-o secvență diferită. Dacă o clasă are mulți constructori și unul dintre ei folosește cuvântul cheie this() pentru a apela un alt constructor, schimbarea ordinii constructorilor poate schimba modul în care se comportă un program.

O modalitate diferită de a înlănțui constructorii folosind blocul Init

Utilizarea unui bloc de inițializare este o altă abordare a înlănțuirii constructorilor în Java .O secțiune de cod cunoscută sub numele de bloc de inițializare rulează be

Elementele esențiale ale înlănțuirii constructorului în Java

Când numim un Constructor de la un alt Constructor din aceeași clasă, ceea ce se întâmplă este cunoscut sub numele de Constructor Chaining. Scopul principal al facerii Constructor Chaining este de a trece parametrii printr-o mulțime de constructori diferiți și de a-i inițializa doar într-un singur loc. În acest fel, aveți șansa de a menține toate inițializările într-o singură locație, în timp ce diferiți constructori pot fi furnizați utilizatorilor.

Dacă nu efectuați Constructor Chaining și doi Constructori diferiți necesită un parametru, va trebui să inițializați acel parametru de două ori. În plus, de fiecare dată când inițializarea se schimbă, va trebui să faceți modificările respective tuturor constructorilor în loc de doar unul.

Ca regulă generală, ar trebui să apelați întotdeauna Constructori cu mai multe argumente de la Constructori care au mai puține argumente. De asemenea, trebuie să știți că putem supraîncărca mai mulți Constructori din clasă. Cu toate acestea, în momentul în care un obiect este creat, este apelat doar un anumit Constructor. Pot exista destul de multe situații în timpul programării în Java în care ar trebui să apelați mai mulți constructori unul de la altul fără a crea obiecte diferite. Acest mecanism de invocare a unui Constructor de la un alt constructor și atunci când constructorul implicat invocă un alt constructor este cunoscut ca înlănțuire a constructorului.

Învațăcursuri de softwareonline de la cele mai bune universități din lume.Câștigați programe Executive PG, programe avansate de certificat sau programe de master pentru a vă accelera cariera.

Există două lucruri principale de care ar trebui să ții cont în legătură cu Constructor Chaining pentru a asigura cea mai mare claritate:

• Scopul principal al Constructor Chaining este de a menține codul. Ideea este să vă ajute să scrieți o singură bucată de cod care poate fi reutilizată în programul dvs. În acest fel, nu numai că codul tău va fi curat și lizibil, dar va fi, de asemenea, mult mai ușor de gestionat, toate corecțiile și modificările având loc doar într-o singură locație în loc de toți Constructorii.
• Constructorul care a fost invocat nu creează un obiect separat. În schimb, folosește obiectul care rulează în prezent pentru a invoca un alt constructor. Este la fel ca și cum ai apela la o metodă diferită în interiorul Constructorului tău, cu excepția faptului că este și un constructor.

După cum ați văzut în exemplul anterior, am folosit acest cuvânt cheie pentru a accesa parametrii Constructorului. De asemenea, Constructor Chaining necesită, de asemenea, în principal două cuvinte cheie. Iată cele două cuvinte cheie:

• this – Reprezentarea metodei sale apelează un constructor de clasă curentă.
• super – Reprezentarea metodei sale apelează un constructor imediat super sau superclasă părinte.

În plus, ar trebui să fiți conștienți de alți câțiva termeni și definiții importanți în ceea ce privește Constructor Chaining în Java:

• Invocarea constructorului: Când invocați un constructor și acel constructor este invocat cu succes, este cunoscut sub numele de invocare a constructorului.
• Execuția constructorului: Dacă la invocarea Constructorului, controlul începe să execute instrucțiunile din corpul Constructorului. Este cunoscut sub numele de execuție constructor.

Regulile cheie ale înlănțuirii constructorilor în Java

Cu elementele de bază ale Constructor Chaining stabilite, să ne uităm la câteva reguli esențiale de lucru cu Constructor Chaining în Java:

• this() poate apela doar parametrii care aparțin aceluiași Constructor.
• super() poate apela numai constructorul imediat al superclasei.
• this() și super() ar trebui să fie prima declarație din Constructor.
• Acest () și super() nu pot fi folosite în același Constructor, deoarece ambii indivizi trebuie să fie primele declarații, ceea ce nu este practic posibil.
• Nu puteți adăuga this() în toți Constructorii aceleiași clase, deoarece ar trebui să existe cel puțin un Constructor fără această instrucțiune ().
• Invocarea și executarea Constructorilor în Java se întâmplă invers. Deci, dacă Constructorii au fost chemați în ordinea A, B, C, atunci execuția va fi în ordinea C, B, A.

De exemplu, aici, avem două clase separate care funcționează prin supraîncărcarea Constructorilor diferiți. Vrem să executăm constructorii în ordinea 2, 1, 4, 3, 5.

Pentru a executa constructori în ordine, trebuie să apelăm constructorii exact în ordine opusă, cum ar fi 5, 3, 4, 1, 2, vezi în exemplul de mai jos.

Părinte de clasă

{

Părinte()// 1

{

asta(„bună ziua”);

System.out.println(„în Parent 0 arg constructor 1”);

}

Părinte (șir de mesaje)// 2

{

System.out.println(„în constructorul Parent(String) 2”);

}

}

class Constructor extinde Parent

{

Constructor()// 3

{

this(10);// apelând constructorul de 5 numere

System.out.println(„în constructorul 0 arg constructor 3”);

}

Constructor(String msj)// 4

{

super();//apelarea constructorului clasei părinte a 1 număr

System.out.println(“in Constructor(String msg) arg constructor 4”);

}

Constructor(int i)// 5

{

this(„bună ziua”);//apelarea constructorului de 4 numere

System.out.println(„în Constructor(int i) constructor 5”);

}

// metoda main().

public static void main(String[] args)

{

Constructor cobj = constructor nou(); // apelarea constructorului de 3 numere

}

}

Ieșire:

în constructorul Parent(String) 2

în Parent 0 arg constructor 1

în Constructor(String msg) arg constructor 4

în Constructor(int i) constructor 5

în Constructor 0 arg constructor 3

Rezumând toate conceptele de Constructori și Constructor Chaining în Java cu un exemplu final:

clasa Emp

{

public String ENname;

veniturile publice int;

adresa public String;

public Emp()

{

aceasta ("Rahul");

}

public Emp (nume șir)

{

aceasta (nume, 140035);

}

public Emp(Nume șir, int sal)

{

aceasta (nume, sal, „New Delhi”);

}

Angajat public (nume șir, int sal, șir add)

{

this.EName=nume;

aceasta.EEarnings=sal;

this.address=adăugați;

}

void disp() {

System.out.println(„Nume: „+EName);

System.out.println(„Salariu: „+ECâsguri);

System.out.println(„Adresă: „+adresă);

}

public static void main(String[] args)

{

Employee obj = nou Employee();

obj.disp();

}

}

Ieșire:

Nume angajat: Rahul

Salariu angajat: 140035

Adresa angajatului: New Delhi

Concluzie

Cu asta, ajungem la finalul acestui articol. Sperăm că acest lucru v-a clarificat îndoielile cu privire la Constructor Chaining în Java și v-a consolidat înțelegerea în continuare. La upGrad, credem că îi ajutăm pe studenții din întreaga lume să-și atingă potențialul maxim și să reușească în cariera lor. Cursurile noastre sunt concepute ținând cont atât de cei proaspăt, cât și de profesioniștii cu experiență.

Un astfel de curs este certificarea PG legată de locuri de muncă de la upGrad în inginerie software , conceput special pentru cei care caută pentru prima dată un loc de muncă. Consultați conținutul cursului și înscrieți-vă astăzi! Învățați toate abilitățile relevante de inginerie software, cum ar fi Java, DSA, OODAP, JavaScript, MERN, AWS etc., de la experți din industrie și profesioniști de top.