Pagpasa ng mga parameter sa Java

Ang isang variable sa Java ay isang lalagyan na may halaga sa loob nito. Kaya ano ang ibig sabihin ng "ipasa" ang isang variable? At ano ang pagkakaiba sa pagitan ng primitive at reference na mga uri ng data. Aabangan natin yan mamaya. Magsimula muna tayo sa isang simpleng takdang-aralin. Ano ang ginagawa ng code na ito:

int х = 3;
int у = х;

Sa linya 1, ang isang variable na x ng uri ng int ay nilikha at itinalaga ang halaga 3. Sa linya 2, isang variable na y ng uri ng int ay nilikha at itinalaga ang halaga ng variable na x . Sa hinaharap, ang variable na x ay hindi makakaapekto sa y sa anumang paraan . Kinokopya ng Java ang halaga ng x (3) at mga lugar na kinokopya sa y . Ito ay nagpapasa ng isang parameter ayon sa halaga. Hindi ka nagsusulat ng isang variable sa isa pa. Ang halaga ay kinopya at itinalaga sa isang bagong variable. Expression y = x; HINDI nangangahulugang "isulat ang x sa y ". Nangangahulugan ito na "kopyahin ang halaga sa loob ng x at isulat ang kopya na iyon sa y ." Kung mamaya papalitan ko y :

у = 34;

Makakaapekto ba ito sa x ? Syempre hindi. Ang x ay mayroon pa ring halaga na 3. Kung babaguhin ko ang x mamaya :

х = 90;

Paano ito makakaapekto sa y ? Hindi pwede. Hindi sila nauugnay sa anumang paraan pagkatapos gawin ang takdang-aralin (KOPYA sa halaga). Paano ang mga uri ng sanggunian? Paano sila gumagana? Hindi ganoon kahirap, sa katunayan ang panuntunan ay pareho. Ginagawa ng mga link ang parehong bagay - makakakuha ka ng kopya ng link. Kaya kung sasabihin ko:

Cat A = new Cat ();
Cat B = A;

Ang link A ay kinopya sa link B. Hindi ito nalalapat sa bagay - mayroon ka pa ring isang bagay. Ngunit ngayon ay mayroon kang dalawang magkaibang sanggunian na kumokontrol sa parehong bagay na Cat . Ngayon tingnan natin ang pagpasa ng mga parameter sa mga pamamaraan. Ang Java ay nagpapasa ng mga parameter ayon sa halaga. Laging. Nangangahulugan ito na "kopyahin ang halaga at ipasa ang kopya." Para sa mga primitive na uri ito ay madali:

int х = 5;
doStuff (х); / / Передать копию х (meaning 5) в метод doStuff

Ang paraan ng doStuff ay ganito:

void doStuff (int у) {

   / / Действия с 'y'
}

Ang isang kopya ng halaga ng x , ibig sabihin, 5, ay ipinapasa sa doStuff() na pamamaraan . Ang doStuff() na pamamaraan ay may sariling variable na tinatawag na y . Ang y variable ay bago, ibang variable. Sa isang kopya ng kung ano ang nasa x sa oras ng pagpasa nito sa pamamaraan. Mula ngayon, ang y at x ay walang epekto sa isa't isa. Kapag binago mo ang y , hindi mo maaapektuhan ang x .

void doStuff (int у) {

   у = 27; / / Это не влияет на 'х'
}

At vice versa - kung babaguhin mo ang x , hindi mo babaguhin ang y . Ang tanging ginawa ng x sa kasong ito ay kopyahin ang halaga nito at ipasa ito sa doStuff() method . Paano gumagana ang "pass by value" sa mga reference? Masyadong maraming tao ang nagsasabing, "Ang Java ay nagpapasa ng mga primitive na uri ayon sa halaga at mga bagay sa pamamagitan ng sanggunian." Hindi ito ang sinasabi nila. Ipinapasa ng Java ang lahat sa pamamagitan ng halaga. Sa mga primitive, makakakuha ka ng kopya ng nilalaman. Sa mga link makakakuha ka rin ng kopya ng nilalaman. Ngunit ano ang nilalaman ng link? Remote control. Mga pasilidad para sa pamamahala/pag-access sa pasilidad. Kapag nagpasa ka ng isang sanggunian sa isang bagay sa isang pamamaraan, nagpapasa ka ng kopya ng sanggunian. Remote control na clone. Ang bagay ay nakaupo pa rin sa pile kung saan ito nilikha, naghihintay para sa isang tao na gumamit ng remote control. Walang pakialam ang pasilidad kung gaano karaming mga remote ang "na-program" para makontrol ito. Ang tanging nagmamalasakit dito ay ang basurero at ikaw, ang programmer. Kaya kapag sinabi mong:

Cat A = new Cat ();
doStuff (А);

void doStuff (Cat B) {

   / / Использование B
}

Mayroon lamang isang bagay na Pusa . Ngunit ngayon, dalawang remote control (link) ang makaka-access sa parehong Cat object . Kaya ngayon anuman ang gagawin ni B sa object ng Cat ay makakaapekto sa Cat na itinuro ng A , ngunit hindi ito makakaapekto sa mga nilalaman ng A ! Maaari mong baguhin ang Cat gamit ang bagong link B (direktang kinopya mula sa A ), ngunit hindi mo mababago ang A. Ano ang ibig sabihin nito? Maaari mong baguhin ang bagay na tinutukoy ni A , ngunit hindi mo mababago ang sanggunian ni A - i-redirect ito sa isa pang bagay o null . Kaya kung babaguhin mo ang reference ng B (hindi ang aktwal na Cat object na binabanggit ni B , ngunit ang value ng reference mismo) hindi mo babaguhin ang value ng A . At vice versa. Kaya:

Cat A = new Cat ();
doStuff (А);

void doStuff (Cat B) {

   B = new Cat (); / / Не повлияет на ссылку A
}

Nangangahulugan lamang na ang B ay tumuturo sa isa pang bagay. Masaya pa rin si A. Kaya ulitin pagkatapos ko: ipinapasa ng Java ang lahat sa pamamagitan ng halaga. (Okay, isa pa... na may pakiramdam.) Ipinapasa ng Java ang lahat sa pamamagitan ng halaga. Para sa mga primitive na uri, nagpapasa ka ng kopya ng kasalukuyang halaga, para sa mga object reference, nagpapasa ka ng kopya ng reference (remote control). Hindi mo kailanman ipinapasa ang bagay. Ang lahat ng mga bagay ay naka-imbak sa heap. Laging. Ngayon magtimpla ng isang mabigat na tasa ng kape at magsulat ng ilang code! Orihinal na artikulo.