Mga Uri ng Reference Data sa Java

Kung walang pag-unawa sa Java syntax, imposibleng maging isang seryosong developer, kaya ngayon ay patuloy nating natutunan ang syntax. Sa isa sa mga nakaraang artikulo ay napag-usapan natin ang tungkol sa mga primitive na variable, ngunit dahil mayroong dalawang uri ng mga variable, ngayon ay pag-uusapan natin ang tungkol sa pangalawang uri - mga uri ng sanggunian sa Java. Kaya ano ito? Bakit kailangan ang mga uri ng data ng sanggunian sa Java? Isipin natin na mayroon tayong TV object na may ilang katangian, gaya ng channel number, sound volume at on flag:

public class TV {
   int numberOfChannel;
   int soundVolume;
   boolean isOn;
}

Paano intmaiimbak ng isang simpleng uri ang , ang data na ito? Tandaan natin: ang isang variable intay 4 bytes. Ngunit sa loob mayroong dalawang variable (4 bytes + 4 bytes) ng parehong uri, at gayundin boolean(+1 byte)... Kabuuan - 4 hanggang 9, ngunit bilang isang panuntunan, marami pang impormasyon ang nakaimbak sa isang bagay. Anong gagawin? Hindi mo maaaring ilagay ang isang bagay sa isang variable. Sa puntong ito sa aming kuwento, lumilitaw ang mga sangguniang variable. Ang mga reference na variable ay nag-iimbak ng address ng lokasyon ng memorya kung saan matatagpuan ang isang partikular na bagay. Iyon ay, ito ay isang "business card" na may isang address, kung saan maaari naming mahanap ang aming bagay sa nakabahaging memorya at magsagawa ng ilang mga manipulasyon dito. Ang isang reference sa anumang bagay sa Java ay isang reference variable. Ito ang magiging hitsura ng aming bagay sa TV:

TV telly = new TV();

Nagtakda kami ng variable ng uri ng TV na may pangalan tellysa isang link sa nilikhang bagay ng uri ng TV. Iyon ay, ang JVM ay naglalaan ng memorya sa heap para sa TV object, nililikha ito at ang address sa lokasyon nito sa memorya, inilalagay ito sa variable telly, na nakaimbak sa stack. Maaari kang magbasa ng higit pa tungkol sa memorya, lalo na ang stack at maraming iba pang kapaki-pakinabang na impormasyon, sa lecture na ito . Isang variable ng uri ng TV at isang bagay ng uri ng TV, napansin mo ba? Ito ay hindi walang dahilan: ang mga bagay ng isang tiyak na uri ay dapat na may kaukulang mga variable ng parehong uri (hindi binibilang ang mana at mga pagpapatupad ng interface, ngunit ngayon ay hindi namin ito isinasaalang-alang). Sabagay, hindi naman tayo magbubuhos ng sopas sa baso, di ba? Lumalabas na ang aming bagay ay isang TV, at ang reference na variable para dito ay parang control panel. Gamit ang remote control na ito maaari tayong makipag-ugnayan sa ating object at sa data nito. Halimbawa, itakda ang mga katangian para sa aming TV:

telly.isOn = true;
telly.numberOfChannel = 53;
telly.soundVolume = 20;

Dito ginamit namin ang dot operator .upang ma-access at simulan ang paggamit ng mga panloob na elemento ng bagay na tinutukoy ng variable. Halimbawa, sa unang linya sinabi namin ang variable na telly: "Bigyan kami ng panloob na variable isOnng bagay na iyong tinutukoy at itakda ito sa true" (i-on ang TV para sa amin).

Muling pagtukoy sa mga sangguniang variable

Sabihin nating mayroon tayong dalawang variable ng isang uri ng sanggunian at ang mga bagay na tinutukoy nila:

TV firstTV = new TV();
TV secondTV = new TV();

Kung isusulat natin:

firstTV = secondTV;

Nangangahulugan ito na itinalaga namin ang unang variable bilang isang halaga ng isang kopya ng address (ang halaga ng mga bit ng address) sa pangalawang bagay, at ngayon ang parehong mga variable ay tumutukoy sa pangalawang bagay (sa madaling salita, dalawang remote control para sa parehong TV). Kasabay nito, ang unang bagay ay naiwan na walang variable na tumutukoy dito. Bilang isang resulta, mayroon kaming isang bagay na hindi ma-access, dahil ang variable ay isang kondisyon na sinulid dito, kung wala ito ay nagiging basura, namamalagi lamang sa memorya at tumatagal ng espasyo. Ang bagay na ito ay kasunod na sisirain mula sa memorya ng tagakolekta ng basura . Maaari mong sirain ang nagkokonektang thread sa isang bagay na walang ibang link:

secondTV = null;

Bilang resulta, magkakaroon lamang ng isang link sa object - firstTV, at secondTVhindi na ituturo sa sinuman (na hindi pumipigil sa amin na italaga ito ng isang link sa ilang bagay tulad ng TV sa hinaharap).

Klase ng string

Hiwalay, gusto kong banggitin ang String class . Ito ay isang base class na idinisenyo para sa pag-iimbak at pagtatrabaho sa data na nakaimbak bilang isang string. Halimbawa:

String text = new String("This TV is very loud");

Dito ay naipasa namin ang isang string na itatabi sa constructor ng object. Pero walang gumagawa nun. Pagkatapos ng lahat, maaaring malikha ang mga string:

String text = "This TV is very loud";

Mas maginhawa, tama? Sa mga tuntunin ng katanyagan ng paggamit, Stringhindi ito mas mababa sa mga primitive na uri, ngunit ito ay isang klase pa rin, at ang variable na tumutukoy dito ay hindi isang primitive na uri, ngunit isang uri ng sanggunian. Mayroon kaming Stringganitong kahanga-hangang kakayahang pagdugtungin ang mga string:

String text = "This TV" + " is very loud";

Bilang resulta, muli nating makukuha ang teksto: This TV is very loud, dahil ang dalawang linya ay pagsasama-samahin sa isang buo, at ang variable ay tumutukoy sa buong tekstong ito. Ang isang mahalagang nuance ay na Stringito ay isang hindi nababagong klase. Ano ang ibig sabihin nito? Kunin natin ang halimbawang ito:

String text = "This TV";
text = text + " is very loud";

Tila ang lahat ay simple: ipinapahayag namin ang isang variable, bigyan ito ng isang halaga. Sa susunod na linya ay binago namin ito. Pero hindi talaga kami nagbabago. Dahil ito ay isang hindi nababagong klase, sa pangalawang linya ang paunang halaga ay hindi binago, ngunit isang bago ay nilikha, na kung saan ay binubuo ng una + " is very loud".

Mga pare-parehong sanggunian

Sa artikulo tungkol sa mga primitive na uri, hinawakan namin ang paksa ng mga constants. Paano kikilos ang isang reference na variable kapag idineklara namin itong pinal ?

final TV telly = new TV();

Maaari mong isipin na gagawin nitong hindi nababago ang bagay. Pero hindi, hindi iyon totoo. Ang isang reference na variable na may modifier finalay ipapatali sa isang partikular na bagay nang walang kakayahang alisin ito sa anumang paraan (muling tukuyin ito o itumbas ito sa null). Iyon ay, pagkatapos itakda ang halaga ng naturang variable, code tulad ng:

telly = new TV();

o

telly = null;

magdudulot ng error sa compilation. Iyon ay, finalito ay kumikilos lamang sa link, at walang epekto sa mismong bagay. Kung sa una ay nababago natin ito, maaari nating baguhin ang panloob na estado nito nang walang anumang problema:

telly.soundVolume = 30;

Minsan, ang mga variable ay itinalaga bilang pangwakas kahit na sa mga argumento ng pamamaraan!

public void enableTV (final TV telly){
   telly.isOn = true;
}

Ginagawa ito upang sa panahon ng proseso ng pagsulat ng isang pamamaraan ay hindi ma-override ang mga argumentong ito at, nang naaayon, ay lumikha ng mas kaunting pagkalito. Paano kung tinukoy namin finalang isang reference variable na tumutukoy sa isang hindi nababagong bagay? Hal String:

final String PASSWORD = "password";

Bilang isang resulta, makakakuha tayo ng isang pare-pareho, isang analogue ng mga constants ng isang primitive na uri, dahil dito hindi namin maaaring muling tukuyin ang sanggunian o baguhin ang panloob na estado ng bagay (panloob na data).

Isa-isahin natin

1. Habang ang mga simpleng variable ay nag-iimbak ng mga bit ng halaga, ang mga reference na variable ay nag-iimbak ng mga bit na kumakatawan sa kung paano kinukuha ang isang bagay.
2. Ang mga sanggunian sa bagay ay ipinahayag para lamang sa isang uri ng bagay.
3. Anumang klase sa Java ay isang uri ng sanggunian.
4. Ang default na halaga ng anumang reference na variable sa Java ay null.
5. Stringay isang karaniwang halimbawa ng isang uri ng sanggunian. Ang klase na ito ay hindi rin nababago.
6. Ang mga reference na variable na may modifier finalay nakatali sa isang bagay lamang nang walang posibilidad na muling tukuyin.