Ang isang constructor ay isang espesyal na pamamaraan na inilaan upang unang itakda ang mga halaga ng mga patlang ng isang bagay. Sa unang tingin, ang mga object constructor ay hindi gaanong naiiba sa mga ordinaryong object method. At sa katunayan, sa loob ng constructor magagawa natin ang lahat ng magagawa natin sa mga regular na pamamaraan ng object: output ng text sa console, i-access ang lahat ng field at pamamaraan ng bagong object, throw exception, at iba pa. Tulad ng mga regular na pamamaraan, ang mga konstruktor ay maaaring magkaroon ng mga argumento. Tulad ng mga overloaded na pamamaraan, maaaring mayroong ilang mga konstruktor na may iba't ibang mga lagda. Tulad ng mga generic na pamamaraan, ang mga konstruktor ay maaaring ma-parameter ayon sa mga variable ng uri. Kahit na tingnan natin ang bytecode na nabuo ng compiler, sa lugar kung saan dapat mayroong isang tawag sa constructor, makakahanap tayo ng isang tawag sa ilang pamamaraan na may pangalan kung saan ang tawag ay hindi naiiba sa tawag sa iba pang mga pamamaraan <init>ng ang bagay. At kapag natagpuan ang bytecode ng pamamaraang ito, makikita natin na naglalaman ito ng resulta ng pag-compile ng ating constructor. Tila na walang maraming mga pagkakaiba mula sa mga maginoo na pamamaraan, ngunit mayroon sila, at medyo makabuluhan. Una, alamin natin, bakit kailangan talaga natin ng mga constructor? Upang mag-imbak at magproseso ng anumang data, ito man ay mga primitive na uri, array, o bagay, kailangan namin ng isang tiyak na halaga ng memorya. Maaari itong maging mga rehistro ng processor, puwang ng stack, o isang piraso ng puwang na inilalaan sa seksyon ng data ng proseso, o sa isang bahagi ng memory na dynamic na inilalaan (heap). Sa maraming mga programming language, para sa mga layunin ng pagpapabilis, kapag ang isang programa ay humiling ng isang bagong piraso ng memorya, ang memorya ay ibinigay sa program na hindi na-clear, at maaaring maglaman ng di-makatwirang data na naka-imbak sa memory cell na ito nang mas maaga. Inihahanda at isulat ang mga kinakailangang halaga sa isang piraso ng memorya upang sa wakas ay magkakaroon ng ilang makabuluhang istraktura ng data doon ay bumagsak sa mga balikat ng programmer. Naturally, gusto ng mga programmer na gawing mas madali ang kanilang buhay at nagsulat ng mga gawain upang simulan (iyon ay, magtakda ng mga paunang halaga) para sa mga madalas na ginagamit na istruktura ng data. Halos palagiang ginagamit ang mga ganitong gawain, kaya nagpasya ang mga tagalikha ng wikang Java na gawing mandatoryong tawagan ang naturang mga gawain sa pagsisimula kapag lumilikha ng mga bagay, at tinawag silang mga constructor . Kapag ang isang bagong bagay ay nilikha sa Java, ang mga sumusunod ay mangyayari: Una, ang Java memory manager ay naglalaan ng halaga ng memorya na kinakailangan upang mapaunlakan ang bagay. Sa kasong ito, hindi lamang ang mga patlang na direktang ipinahayag sa klase ng nilikhang bagay ay isinasaalang-alang, kundi pati na rin ang mga patlang na ipinahayag sa lahat ng mga ninuno ng klase na ito. Bukod pa rito, kasama sa volume na ito ang espasyo para sa paglalagay ng mga istruktura na ginagamit ng Java machine para sa mga panloob na pangangailangan. Ang lahat ng mga field ng naturang "blangko" ay awtomatikong nakatakda sa mga default na halaga - nullpara sa mga uri ng sanggunian, 0para sa mga numero at falsepara saboolean. Pagkatapos nito, ang tagabuo ng klase ay awtomatikong tinatawag, na ang gawain ay upang itakda ang mga paunang halaga ng mga patlang ng bagay. Habang sa isang normal na pamamaraan ang unang pahayag ay maaaring maging anuman, ang tagabuo ay may mas kaunting kalayaan. Ang unang pahayag ng isang constructor ay dapat na alinman sa isang tahasang tawag sa isa pang constructor ng parehong klase, o isang tahasan o implicit na tawag sa isang constructor ng isang parent class. Ang mga tahasang tawag sa mga konstruktor ng parehong klase ay ginagawa gamit ang isang keyword thisna sinusundan ng isang hanay ng mga argumento na nakapaloob sa mga panaklong. Ang pagtawag sa tagabuo ng isang klase ng magulang ay tahasang ginagawa sa eksaktong parehong paraan, ngunit ginagamit ang keyword super. Sa mga argumento ng isang tahasang tawag sa constructor ng pareho o parent na klase, hindi mo ma-access ang mga field at pamamaraan ng object, pati na rin gamitin ang mga keyword thisat super, dahil ang isang tahasang tawag sa constructor ay nagpapakilala ng isang static na konteksto. Upang implicitly na tawagan ang constructor ng isang parent class, hindi mo kailangang magsulat ng kahit ano, ngunit ang default na constructor ay implicitly na tinatawag, na dapat umiral at makikita ng kasalukuyang klase. Kasabay nito, dapat tandaan na kung ang kadena ng pagtawag sa mga constructor ng magulang ay nagambala bago Objectmatagumpay na nakumpleto ng tagabuo ng klase na matatagpuan sa tuktok ng kadena ang gawain nito, kung gayon ang bagay ay hindi matatapos, iyon ay, ang pamamaraan. finalize()ng gayong bagay ay hindi kailanman tatawagin. Pagkatapos makumpleto ng parent class constructor, ang kontrol ay tahasang inililipat sa mga bloke ng instance initializer at mga instance field initializer ng kasalukuyang klase. Ang mga initializer ay isinasagawa sa pagkakasunud-sunod kung saan lilitaw ang mga ito sa teksto ng programa. Pagkatapos lamang makumpleto ng mga initializer ang kanilang trabaho ay ililipat ang kontrol sa natitirang bahagi ng konstruktor. Ang natitirang mga tampok ng mga konstruktor ay nauugnay sa modelo ng memorya ng Java. Kung ang isang klase, o isa sa mga ninuno nito, ay na-override ang method finalize(), kung gayon ang pagkumpleto ng constructor ay mangyayari bago ( happens-before ) ang pamamaraan ay tumatakbo finalize(). Kung ang anumang thread ay nakakita ng isang reference sa isang bagay pagkatapos makumpleto ang constructor, kung gayon ito ay garantisadong na ang thread na ito ay makikita ang tama ang initialized final-fields ng object, ang initialization na nangyari bago ang pagkumpleto ng constructor.
GO TO FULL VERSION