Ce este Constructor în Java?
CONSTRUCTOR este o metodă specială care este utilizată pentru a inițializa un obiect nou creat și se numește imediat după ce memoria este alocată obiectului. Poate fi folosit pentru a inițializa obiectele la valorile dorite sau la valorile implicite în momentul creării obiectului. Nu este obligatoriu ca programatorul să scrie un constructor pentru o clasă.
Dacă nu este prevăzut un constructor definit de utilizator pentru o clasă, compilatorul inițializează variabilele membre la valorile sale implicite.
- tipurile de date numerice sunt setate la 0
- tipurile de date char sunt setate la caracter nul ('\ 0')
- variabilele de referință sunt setate la nul
În acest tutorial, veți învăța-
- Reguli pentru crearea unui constructor
- Supraîncărcarea constructorului în Java
- Înlănțuirea constructorului
Reguli pentru crearea unui constructor Java
- Are același nume ca și clasa
- Nu ar trebui să returneze o valoare nici măcar nulă
Exemplul 1 : Creați primul dvs. constructor în Java
Pasul 1) Tastați următorul program constructor în editorul Java.
class Demo{int value1;int value2;Demo(){value1 = 10;value2 = 20;System.out.println("Inside Constructor");}public void display(){System.out.println("Value1 === "+value1);System.out.println("Value2 === "+value2);}public static void main(String args[]){Demo d1 = new Demo();d1.display();}}
Pasul 2) Salvați, rulați și compilați programul constructor în Java și observați ieșirea.
Ieșire:
Inside ConstructorValue1 === 10Value2 === 20
Supraîncărcarea constructorului în Java
Supraîncărcarea Java Constructor este o tehnică în care o clasă poate avea orice număr de constructori care diferă în lista de parametri. Compilatorul diferențiază acești constructori ținând cont de numărul de parametri din listă și de tipul acestora.
Exemple de constructori valizi pentru clasa Cont sunt
Account(int a);Account (int a,int b);Account (String a,int b);
Exemplul 2 : Pentru a înțelege supraîncărcarea constructorului în Java
Pasul 1) Tastați codul în editor.
class Demo{int value1;int value2;/*Demo(){value1 = 10;value2 = 20;System.out.println("Inside 1st Constructor");}*/Demo(int a){value1 = a;System.out.println("Inside 2nd Constructor");}Demo(int a,int b){value1 = a;value2 = b;System.out.println("Inside 3rd Constructor");}public void display(){System.out.println("Value1 === "+value1);System.out.println("Value2 === "+value2);}public static void main(String args[]){Demo d1 = new Demo();Demo d2 = new Demo(30);Demo d3 = new Demo(30,40);d1.display();d2.display();d3.display();}}
Pasul 2) Salvați, compilați și rulați codul.
Pasul 3) Eroare =?. Încercați și depanați eroarea înainte de a trece la pasul următor al supraîncărcării constructorului Java
Pasul 4) Fiecare clasă are un constructor implicit în Java. Constructorul implicit Java supraîncărcat pentru clasa Demo este Demo () . În cazul în care nu furnizați acest constructor, compilatorul îl creează pentru dvs. și inițializează variabilele la valorile implicite. Puteți alege să înlocuiți acest constructor implicit și să inițializați variabilele la valorile dorite, așa cum se arată în Exemplul 1.
Dar dacă specificați un constructor parametrizat precum Demo (int a) și doriți să utilizați constructorul implicit Java Demo (), este obligatoriu să îl specificați.
Cu alte cuvinte, în cazul în care constructorul dvs. de supraîncărcare în Java este suprascris și doriți să utilizați constructorul implicit Java, trebuie specificat.
Pasul 5) Linia de comentariu nr. 4-8. Salvați, compilați și rulați codul.
Înlănțuirea constructorului
Luați în considerare un scenariu în care o clasă de bază este extinsă de un copil. Ori de câte ori este creat un obiect al clasei copil, este invocat mai întâi constructorul clasei părinte. Aceasta se numește înlănțuirea constructorului.
Exemplul 3: Înțelegerea înlănțuirii constructorilor
Pasul 1) Copiați următorul cod în editor.
class Demo{int value1;int value2;Demo(){value1 = 1;value2 = 2;System.out.println("Inside 1st Parent Constructor");}Demo(int a){value1 = a;System.out.println("Inside 2nd Parent Constructor");}public void display(){System.out.println("Value1 === "+value1);System.out.println("Value2 === "+value2);}public static void main(String args[]){DemoChild d1 = new DemoChild();d1.display();}}class DemoChild extends Demo{int value3;int value4;DemoChild(){//super(5);value3 = 3;value4 = 4;System.out.println("Inside the Constructor of Child");}public void display(){System.out.println("Value1 === "+value1);System.out.println("Value2 === "+value2);System.out.println("Value1 === "+value3);System.out.println("Value2 === "+value4);}}
Pasul 2) Rulați codul. Datorită înlănțuirii constructorului, când se creează obiectul clasei copil DemoChild, se invocă mai întâi constructorul Demo () al clasei părinte și mai târziu se creează constructorul DemoChild () al copilului. Ieșire așteptată =
Inside 1st Parent ConstructorInside the Constructor of ChildValue1 === 1Value2 === 2Value1 === 3Value2 === 4
Pasul 3) Puteți observa că constructorul clasei părinte Demo este suprascris. Ce se întâmplă dacă doriți să apelați constructorul suprascris Demo (int a) în locul constructorului implicit Demo () atunci când este creat obiectul dvs. copil?
În astfel de cazuri, puteți utiliza cuvântul cheie „super” pentru a apela constructorii suprascriși ai clasei părinte.
Sintaxă:-
super();--or--super(parameter list);
Exemplu: Dacă constructorul dvs. este ca Demo (String Name, int a), veți specifica super ("Java", 5) Dacă este utilizat, cuvântul cheie super trebuie să fie prima linie de cod din constructorul clasei copil.
Pasul 4) Decomentați linia # 26 și rulați codul. Observați ieșirea.
Ieșire:
Inside 2nd Parent ConstructorInside the Constructor of ChildValue1 === 5Value2 === 0Value1 === 3Value2 === 4