În Java, constructorii joacă un rol crucial în inițializarea instanței clasei. Acestea sunt similare cu metodele Java. Cu toate acestea, numele constructorului este întotdeauna același cu numele clasei, în timp ce o metodă normală poate avea orice nume valid. De cele mai multe ori, acestea sunt denumite și metode speciale pentru a declara un obiect. Puteți crea înlănțuirea constructorului care are loc cu ajutorul moștenirii. Constructorul copil/subclasă apelează mai întâi constructorul părinte/superclasă și apoi, constructorii clasei copil pot fi invocați.
Această postare va spune despre înlănțuirea constructorului în Java.
Constructor Chaining în Java
Schimbarea constructorului este cea mai importantă procedură pentru chemarea unui constructor într-un alt constructor conform obiectivelor enunțate. Una dintre utilizările principale ale înlănțuirii constructorilor este evitarea codurilor redundante în timp ce aveți mai mulți constructori. Face codul ușor de înțeles și de citit.
Există două metode de a efectua înlănțuirea constructorului în Java, așa cum este menționat mai jos:
Să verificăm aceste metode una câte una pentru o mai bună înțelegere a înlănțuirii constructorilor.
Metoda 1: Înlănțuirea constructorului în cadrul aceleiași clase folosind cuvântul cheie „this()”.
Când înlănțuirea constructorului este efectuată în cadrul aceleiași clase, Java „ acest() ” este folosit cuvântul cheie. Constructorul implicit va fi invocat atunci când este inițiată o instanță de clasă. Va apela un alt constructor folosind „ acest ” cuvânt cheie. Apoi, invocați metoda „println()” pentru afișarea rezultatului pe consolă:
min ( ) {
acest ( 5 ) ;
System.out.println ( „Constructorul implicit” ) ;
}
Acum, apelați al doilea constructor format dintr-un parametru „ A ” și setați valoarea parametrilor în „ acest() ” cuvânt cheie. Apoi, utilizați „ println() ” și treceți „a” ca argument pentru a afișa rezultatul:
acest ( 5 , douăzeci ) ;
System.out.println ( A ) ;
}
În acest constructor, am trecut cei doi parametri de tip întreg ca „ A ' și ' b ”. După aceea, invocați metoda „println()” și transmiteți „ a*b ” care va returna produsul acestor variabile:
System.out.println ( A * b ) ;
}
În ' principal() ”, invocați constructorul implicit care va apela automat ceilalți constructori și va afișa rezultatul pe consolă:
nou min ( ) ;
}
Ca rezultat, rezultatul tuturor constructorilor va fi afișat pe consolă:
Dacă doriți să înlănțuiți constructorul în mai multe clase, consultați metoda menționată mai jos.
Metoda 2: Înlănțuirea constructorului la o altă clasă folosind cuvântul cheie „super()”.
De asemenea, puteți înlănțui constructorii de la o clasă la alta. Pentru aceasta, este folosit cuvântul cheie „super()”. Pentru a face acest lucru, utilizați următorul cod în clasa principală.
Mai întâi de toate, definiți o variabilă de tip șir „ Nume ” și apelați primul constructor folosind numele clasei principale:
Nume șir;min ( ) {
acest ( '' ) ;
System.out.println ( „Fără constructorul clasei de bază” ) ;
}
Invocați al doilea constructor și transmiteți variabila declarată mai sus „ Nume șir ” ca parametru. Folosește ' acest ” pentru a accesa valoarea și pentru a invoca “ println() ” metoda pentru imprimare:
this.name = nume;
System.out.println ( „Apelarea constructorului parametrizat al bazei” ) ;
}
În interiorul ' principal() ”, apelați clasa copil cu parametrul “ Nume ”. Aceasta va apela constructorii clasei părinte unde parametrul „ Nume ' a trecut. Apoi, va invoca constructorul clasei copil cu parametrul „ Nume ”:
Copil nou ( 'Nume' ) ;
}
Este creată o clasă copil care folosește „ se extinde ” pentru a moșteni clasa părinte și pentru a invoca al treilea constructor. După aceea, apelați următorul constructor și în interiorul acestui constructor, invocați al doilea constructor al clasei părinte:
Copil ( ) {
System.out.println ( „Fără argument constructor al clasei copil” ) ;
}
Copil ( Nume șir ) {
super ( Nume ) ;
System.out.println ( 'Apelarea constructorului parametrizat al copilului' ) ;
}
}
Ieșire
Acesta este totul despre înlănțuirea constructorului în Java.
Concluzie
În Java, înlănțuirea constructorului în aceeași clasă se face folosind cuvântul cheie „this()”, în timp ce cuvântul cheie „super()” este folosit pentru a efectua înlănțuirea constructorului pe diferite clase. Înlănțuirea constructorului are loc cu ajutorul moștenirii. Constructorul de sub-clasă apelează mai întâi constructorul de super-clasă și apoi, constructorii de clasa copil pot fi invocați. Această postare a discutat despre înlănțuirea constructorului în Java cu exemple practice.