Sa Java, ang mga constructor ay may mahalagang papel sa pagsisimula ng instance ng klase. Ang mga ito ay katulad ng mga pamamaraan ng Java. Gayunpaman, ang pangalan ng constructor ay palaging pareho sa pangalan ng klase habang ang isang normal na paraan ay maaaring magkaroon ng anumang wastong pangalan. Kadalasan, ang mga ito ay tinutukoy din bilang mga espesyal na pamamaraan upang magdeklara ng isang bagay. Maaari kang lumikha ng constructor chaining na nangyayari sa tulong ng mana. Ang bata/subclass constructor ay unang tumatawag sa magulang/superclass constructor at pagkatapos, ang child-class na constructor ay maaaring i-invoke.
Ang post na ito ay magsasabi tungkol sa constructor chaining sa Java.
Constructor Chaining sa Java
Ang pagpapalit ng constructor ay ang pinakamahalagang pamamaraan para sa pagtawag sa isang constructor sa isa pang constructor ayon sa mga nakasaad na layunin. Ang isa sa mga pangunahing gamit ng constructor chaining ay upang maiwasan ang mga redundant code habang mayroong maraming constructor. Ginagawa nitong madaling maunawaan at mabasa ang code.
Mayroong dalawang mga paraan upang maisagawa ang constructor chaining sa Java tulad ng nabanggit sa ibaba:
Tingnan natin ang mga pamamaraang ito nang paisa-isa para sa isang mas mahusay na pag-unawa sa constructor chaining.
Paraan 1: Constructor Chaining Sa loob ng Parehong Klase Gamit ang 'this()' Keyword
Kapag ang constructor chaining ay ginanap sa loob ng parehong klase, ang Java ' ito() ” keyword ang ginagamit. Ang default na constructor ay ipapatawag kapag ang isang class instance ay sinimulan. Tatawag ito ng isa pang tagabuo gamit ang ' ito ” keyword. Pagkatapos, gamitin ang 'println()' na paraan para sa pagpapakita ng resulta sa console:
min ( ) {
ito ( 5 ) ;
System.out.println ( 'Ang Default na tagabuo' ) ;
}
Ngayon, tawagan ang pangalawang tagabuo na binubuo ng isang parameter ' a ” at itakda ang halaga ng mga parameter sa “ ito() ” keyword. Pagkatapos, gamitin ang ' println() ” at ipasa ang “a” bilang argumento upang ipakita ang resulta:
ito ( 5 , dalawampu ) ;
System.out.println ( a ) ;
}
Sa constructor na ito, naipasa namin ang dalawang parameter ng uri ng integer bilang ' a 'at' b ”. Pagkatapos nito, i-invoke ang 'println()' na paraan at ipasa ang ' a*b ” na magbabalik ng produkto ng mga variable na ito:
System.out.println ( a * b ) ;
}
Nasa ' pangunahing() ”, i-invoke ang default na constructor na awtomatikong tatawag sa iba pang constructor at ipapakita ang resulta sa console:
bagong min ( ) ;
}
Bilang resulta, ang output ng lahat ng mga konstruktor ay ipapakita sa console:
Kung gusto mong i-chain ang constructor sa maraming klase, tingnan ang nakasaad sa ibaba na paraan.
Paraan 2: Constructor Chaining sa Ibang Klase Gamit ang 'super()' Keyword
Maaari mo ring i-chain ang mga konstruktor mula sa isang klase patungo sa isa pa. Para dito, ginagamit ang keyword na 'super()'. Upang gawin ito, gamitin ang sumusunod na code sa pangunahing klase.
Una sa lahat, tukuyin ang isang variable na uri ng string ' pangalan ” at tawagan ang unang tagabuo sa pamamagitan ng paggamit ng pangunahing pangalan ng klase:
Pangalan ng string;min ( ) {
ito ( '' ) ;
System.out.println ( 'Walang tagabuo ng base class' ) ;
}
I-invoke ang pangalawang constructor at ipasa ang idineklara sa itaas na variable ' Pangalan ng string ” bilang parameter. Gamitin ang ' ito ' keyword upang ma-access ang halaga at i-invoke ang ' println() 'paraan para sa mga layunin ng pag-print:
ito.pangalan = pangalan;
System.out.println ( 'Pagtawag ng parameterized constructor ng base' ) ;
}
Sa loob ng ' pangunahing() 'paraan, tawagan ang klase ng bata na may parameter na ' pangalan ”. Iyon ay tatawag sa parent class constructors kung saan ang parameter na ' pangalan ' ay tapos na. Pagkatapos, tatawagin nito ang tagabuo ng klase ng bata na may parameter na ' pangalan ”:
bagong Bata ( 'pangalan' ) ;
}
Ang isang klase ng bata ay nilikha na gumagamit ng ' umaabot ” na keyword upang magmana ng parent class at i-invoke ang ikatlong constructor. Pagkatapos na tawagan ang susunod na constructor at sa loob ng constructor na ito, i-invoke ang parent class second constructor:
bata ( ) {
System.out.println ( 'Nang walang argumentong tagabuo ng klase ng bata' ) ;
}
bata ( Pangalan ng string ) {
sobrang ( pangalan ) ;
System.out.println ( 'Pagtawag ng parameterized constructor ng bata ' ) ;
}
}
Output
Iyon ay tungkol sa constructor chaining sa Java.
Konklusyon
Sa Java, ang constructor chaining sa parehong klase ay ginagawa gamit ang 'this()' na keyword, habang ang 'super()' na keyword ay ginagamit para magsagawa ng constructor chaining sa iba't ibang klase. Ang constructor chaining ay nangyayari sa tulong ng mana. Tinatawag muna ng sub-class na constructor ang super-class na constructor at pagkatapos, ang child-class na constructor ay maaaring i-invoke. Ang post na ito ay tinalakay ang constructor chaining sa Java na may mga praktikal na halimbawa.