Primitive na mga uri ng data

Hello, Amigo! Gusto kong sabihin sa iyo ang tungkol sa panloob na istraktura ng mga variable. Tulad ng alam mo na, ang bawat variable ay nauugnay sa isang lugar ng memorya kung saan naka-imbak ang halaga nito. "

"Oo. Sinabi mo sa akin ang tungkol sa huling pagkakataon."

"Great. Buti naalala mo. I'll go on, then."

"Ang lahat ng pinagsama-samang uri ay binubuo ng mga mas simple. At sila naman, ay binubuo ng mga mas simple pa. Hanggang sa, sa wakas, napupunta tayo sa mga primitive na uri , na hindi na maaaring pasimplehin pa. Iyon ang tinatawag na mga primitive na uri . Para sa halimbawa, ang int ay isang primitive na uri, ngunit ang String ay isang composite na uri na nag-iimbak ng data nito bilang isang talahanayan ng mga character (kung saan ang bawat karakter ay isang primitive na uri char ).

"Very interesting. Go on."

"Ang mga pinagsama-samang uri ay nabuo sa pamamagitan ng pagpapangkat ng mga simple. Tinatawag namin ang mga ganitong uri ng mga klase . Kapag tinukoy namin ang isang bagong klase sa isang programa, nagdedeklara kami ng bagong pinagsama-samang uri ng data . Ang data nito ay alinman sa iba pang mga pinagsama-samang uri o primitive na uri."

public class Person
{
   String name;
   int age;
}

public class Rectangle
{
   int x, y, width, height;
}

public class Cat
{
   Person owner;
   Rectangle territory;
   int age;
   String name;
}

"Sa ngayon, ang lahat ay malinaw, gayunpaman kakaiba ito ay maaaring mukhang."

"Ang malalaking (composite) na uri ay naglalaman ng maraming maliliit na (primitive) na uri. Kaya naman ang mga bagay ng mga ganitong uri ay kumukuha ng maraming memorya - higit pa sa mga variable ng mga primitive na uri. Minsan higit pa. Ang pagsasagawa ng mga pagpapatakbo ng pagtatalaga na may ganitong mga variable ay dating tumatagal ng mahabang panahon. oras at kinakailangan ang pagkopya ng malalaking seksyon ng memorya.Kaya ang mga variable ng mga pinagsama-samang uri ay hindi nag-iimbak ng mismong bagay, ngunit sa halip ay isang sanggunian lamang dito, ibig sabihin, ang kanyang apat na byte na address.Ito ay sapat na upang matugunan ang data sa naturang mga bagay. Pinangangasiwaan ng Java machine ang lahat ng nauugnay na kumplikado."

"Wala akong naintindihan sa mga iyon."

"Nasabi na natin dati na ang variable ay parang kahon. Kung gusto mong mag-imbak ng numerong 13 dito, maaari mong isulat ang 13 sa isang papel at ilagay ito sa kahon."

"Ngunit isipin na kailangan mong mag-imbak ng isang bagay na mas malaki sa kahon (variable). Halimbawa, isang aso, isang kotse, o iyong kapitbahay. Sa halip na subukang itulak ang hindi maitulak sa kahon, maaari kang gumawa ng isang bagay na mas madali: gumamit ng isang larawan ng aso sa halip na ang aktwal na aso, isang plaka sa halip na isang tunay na kotse, o ang numero ng telepono ng iyong kapitbahay sa halip na ang iyong kapitbahay."

"Kumuha kami ng isang piraso ng papel at isulat ang numero ng telepono ng kapitbahay. Ito ay tulad ng isang reference sa isang bagay. Kung kokopyahin namin ang piraso ng papel na may numero ng telepono ng kapitbahay at ilagay ito sa ilang mga kahon, mayroon na ngayong higit pang mga sanggunian sa kapitbahay mo. Pero gaya ng dati, iisa lang ang kapitbahay mo. May sense naman diba?"

"Ang isang mahalagang tampok ng pag-iimbak ng data sa ganitong paraan ay maaari kang magkaroon ng maraming mga sanggunian sa isang bagay "

"Napakainteresante! Halos nakuha ko na. Sabihin mo sa akin minsan pa, pakiusap – ano ang mangyayari kung magtatalaga ako ng variable ng isang composite type sa isa pang variable ng parehong composite type?"

"Kung gayon ang dalawang variable ay mag-iimbak ng parehong address. Nangangahulugan iyon na kung babaguhin mo ang data ng object na nire-reference ng isang variable, babaguhin mo ang data na isinangguni ng isa . Ang parehong mga variable ay tumutukoy sa parehong bagay . Siyempre, maaaring marami iba pang mga variable na nag-iimbak din ng mga sanggunian dito."

"Ano ang ginagawa ng mga variable ng composite (reference/class) na uri kung wala silang hawak na reference sa isang bagay? Posible ba iyon?"

"Oo, Amigo. Nauunahan mo ako sa iyong tanong. Posible iyon. Kung ang isang variable ng isang uri ng sanggunian (composite) ay hindi nag-iimbak ng isang reference sa isang bagay, pagkatapos ay iniimbak nito ang tinatawag na 'null reference'. Karaniwang, ito ay nangangahulugan na ito ay tumutukoy sa isang bagay na ang address ay 0. Gayunpaman, ang Java machine ay hindi kailanman lumilikha ng mga bagay na may ganitong address, kaya laging alam nito na kung ang isang reference na variable ay naglalaman ng 0, hindi ito tumuturo sa anumang bagay ."

String s;
String s = null;

Person person;
person = new Person();
person = null;

Cat cat = new Cat();
cat.owner = new Person();
cat.owner.name = "God";

"Tama ba ang pagkakaintindi ko sa iyo? Ang mga variable ay nahahati sa dalawang uri: mga primitive na uri at reference na uri. Ang mga primitive na uri ay direktang nag-iimbak ng mga halaga, habang ang mga uri ng reference ay nag-iimbak ng reference sa isang bagay. Ang mga primitive na uri ay kinabibilangan ng int, char, boolean, at marami pang iba. Reference Kasama sa mga uri ang lahat ng iba pa. Gumagamit kami ng mga klase upang gawin ang mga ito."

"Tama ka, anak ko."

"So, sabi mo naintindihan mo na ang lahat. Narito ang ilang gawain para tulungan kang mapalakas ang iyong kaalaman."