Pagpapalawak at Pagpapaliit ng mga primitive na uri

Hi! Habang sumusulong ka sa CodeGym, maraming beses kang nakatagpo ng mga primitive na uri. Narito ang isang maikling listahan ng kung ano ang alam natin tungkol sa kanila:

1. Ang mga ito ay hindi mga bagay at kumakatawan sa isang halaga na nakaimbak sa memorya
2. Mayroong ilang mga uri
   • Buong mga numero: byte , maikli , int , mahaba
   • Floating-point (fractional) na mga numero: float at double
   • Mga lohikal na halaga: boolean
   • Mga simbolikong halaga (para sa kumakatawan sa mga titik at numeral): char

3. Ang bawat uri ay may sariling hanay ng mga halaga:

Ngunit bilang karagdagan sa pagkakaroon ng iba't ibang mga halaga, naiiba din sila sa kung gaano karaming espasyo ang kanilang nasa memorya. Ang isang int ay tumatagal ng higit sa isang byte. At ang isang mahaba ay mas malaki kaysa sa isang maikli. Ang dami ng memorya na inookupahan ng mga primitive ay maihahambing sa mga nesting doll ng Russia: Ang bawat nesting doll ay may espasyong available sa loob. Kung mas malaki ang pugad na manika, mas maraming espasyo ang naroon. Ang isang malaking nesting doll ( mahaba ) ay madaling tumanggap ng mas maliit na int . Madali itong magkasya at hindi mo na kailangang gumawa ng iba pa. Sa Java, kapag nagtatrabaho sa mga primitive, ito ay tinatawag na implicit conversion. O ilagay sa ibang paraan, ito ay tinatawag na widening.

Pagpapalawak sa Java

Narito ang isang simpleng halimbawa ng lumalawak na conversion:

public class Main {

   public static void main(String[] args) {

       int bigNumber = 10000000;

       byte littleNumber = 16;

       bigNumber = littleNumber;
       System.out.println(bigNumber);
   }
}

Dito kami nagtatalaga ng isang byte na halaga sa isang int variable. Ang pagtatalaga ay nagtagumpay nang walang anumang mga problema: ang halaga na nakaimbak sa isang byte ay tumatagal ng mas kaunting memorya kaysa sa kung ano ang maaaring tanggapin ng isang int . Ang maliit na nesting doll (byte value) ay madaling magkasya sa loob ng malaking nesting doll ( int variable). Ito ay ibang bagay kung susubukan mong gawin ang kabaligtaran, ibig sabihin, maglagay ng malaking halaga sa isang variable na ang hanay ay hindi kayang tumanggap ng ganoong kalaking uri ng data. Sa mga totoong nesting doll, hindi magkasya ang bilang. Sa Java, maaari ito, ngunit may mga nuances. Subukan nating maglagay ng int sa isang maikling variable:

public static void main(String[] args) {

   int bigNumber = 10000000;

   short littleNumber = 1000;

   littleNumber = bigNumber;// Error!
   System.out.println(bigNumber);
}

Error! Nauunawaan ng compiler na sinusubukan mong gumawa ng isang bagay na hindi normal sa pamamagitan ng pagtulak ng malaking nesting doll ( int ) sa loob ng maliit ( short ). Sa kasong ito, ang error sa compilation ay isang babala mula sa compiler: "Hoy, sigurado ka ba na gusto mong gawin ito?" Kung sigurado ka, sasabihin mo sa compiler: "Okay lang ang lahat. Alam ko ang ginagawa ko!" Ang prosesong ito ay tinatawag na tahasang uri ng conversion, o pagpapaliit.

Narrowing sa Java

Upang magsagawa ng pagpapaliit na conversion, kailangan mong tahasang isaad ang uri kung saan mo gustong i-convert ang iyong halaga. Sa madaling salita, kailangan mong sagutin ang tanong ng compiler: "Buweno, alin sa mga maliliit na nesting doll na ito ang gusto mong ilagay ang malaking nesting doll na ito?" Sa aming kaso, ganito ang hitsura:

public static void main(String[] args) {

   int bigNumber = 10000000;

   short littleNumber = 1000;

   littleNumber = (short) bigNumber;
   System.out.println(littleNumber);
}

Tahasang ipinapahiwatig namin na gusto naming maglagay ng int sa isang maikling variable at gagawin namin ang responsibilidad. Nakikita na ang isang mas makitid na uri ay tahasang ipinahiwatig, ginagawa ng compiler ang conversion. Ano ang resulta? Output ng console: -27008 Iyon ay medyo hindi inaasahan. Bakit eksaktong nakuha namin iyon? Sa katunayan, ang lahat ng ito ay napaka-simple. Sa orihinal, ang halaga ay 10000000 Ito ay naka-imbak sa isang int variable, na sumasakop sa 32 bits. Ito ang binary na representasyon nito: Isinulat namin ang halagang ito sa isang maikling variable, na maaari lamang mag-imbak ng 16 bits! Alinsunod dito, tanging ang unang 16 bits ng aming numero ang ililipat doon. Ang natitira ay itatapon. Bilang resulta, natatanggap ng maikling variable ang sumusunod na halaga na sa decimal na anyo ay katumbas ng -27008 Iyon ang dahilan kung bakit hinihiling sa iyo ng compiler na "kumpirmahin" sa pamamagitan ng pagpahiwatig ng isang tahasang pagpapaliit ng conversion sa isang partikular na uri. Una, ipinapakita nito na inaako mo ang responsibilidad para sa resulta. At pangalawa, sinasabi nito sa compiler kung gaano karaming espasyo ang ilalaan kapag nangyayari ang pag-convert. Pagkatapos ng lahat, sa huling halimbawa, kung nagtalaga kami ng int value sa isang byte variable sa halip na short , magkakaroon lang kami ng 8 bits sa aming pagtatapon, hindi 16, at magiging iba ang resulta. Ang mga fractional na uri ( float at double ) ay may sariling proseso para sa pagpapaliit ng mga conversion. Kung susubukan mong mag-cast ng factional number sa isang integer type, ang fractional na bahagi ay itatapon.

public static void main(String[] args) {

   double d = 2.7;

   long x = (int) d;
   System.out.println(x);
}

Output ng console: 2

char

Alam mo na ang char ay ginagamit upang magpakita ng mga indibidwal na character.

public static void main(String[] args) {

   char c = '!';
   char z = 'z';
   char i = '8';

}

Ngunit ang uri ng data na ito ay may ilang mga tampok na mahalagang maunawaan. Tingnan natin muli ang talahanayan ng mga hanay ng halaga: Ang hanay na 0 hanggang 65536 ay ipinahiwatig para sa uri ng char . Ngunit ano ang ibig sabihin nito? Pagkatapos ng lahat, ang isang char ay hindi lamang kumakatawan sa mga numero, kundi pati na rin sa mga titik, mga bantas na marka... Ang bagay ay na sa Java char halaga ay naka-imbak sa Unicode format. Nakatagpo na namin ang Unicode sa isa sa mga nakaraang aralin. Malamang naaalala mo na ang Unicode ay isang pamantayan sa pag-encode ng character na kinabibilangan ng mga simbolo ng halos lahat ng nakasulat na wika sa mundo. Sa madaling salita, ito ay isang listahan ng mga espesyal na code na kumakatawan sa halos bawat karakter sa anumang wika. Ang buong talahanayan ng Unicode ay napakalaki, at, siyempre, hindi na kailangang matutunan ito nang buong puso. Narito ang isang maliit na bahagi nito: Ang pangunahing bagay ay upang maunawaan kung paano iniimbak ang mga character, at tandaan na kung alam mo ang code para sa isang partikular na character, maaari mong palaging gawin ang character na iyon sa iyong programa. Subukan natin sa ilang random na numero:

public static void main(String[] args) {

   int x = 32816;

   char c = (char) x ;
   System.out.println(c);
}

Output ng console: 耰 Ito ang format na ginagamit upang mag-imbak ng mga char sa Java. Ang bawat simbolo ay tumutugma sa isang numero: isang 16-bit (two-byte) na numeric code. Sa Unicode, ang 32816 ay tumutugma sa Chinese character na 耰. Itala ang sumusunod na punto. Sa halimbawang ito, gumamit kami ng int variable. Ito ay sumasakop ng 32 bits sa memorya, habang ang isang char ay sumasakop sa 16. Dito pumili kami ng isang int , dahil ang aming numero (32816) ay hindi magkasya sa isang maikling . Bagama't ang laki ng isang char (tulad ng isang short ) ay 16 bits, walang mga negatibong numero sa hanay ng char , kaya ang "positibong" bahagi ng charAng saklaw ay dalawang beses na mas malaki (65536 sa halip na 32767 para sa maikling uri). Maaari kaming gumamit ng int hangga't ang aming code ay nananatili sa ibaba 65536. Ngunit kung lumikha ka ng isang int na halaga na higit sa 65536, kung gayon ito ay sasakupin ng higit sa 16 bits. At ito ay magreresulta sa isang makitid na conversion

char c = (char) x;

ang mga dagdag na piraso ay itatapon (tulad ng tinalakay sa itaas) at ang resulta ay medyo hindi inaasahan.

Mga espesyal na tampok ng pagdaragdag ng mga character at integer

Tingnan natin ang isang hindi pangkaraniwang halimbawa:

public class Main {

   public static void main(String[] args) {

      char c = '1';

      int i = 1;

       System.out.println(i + c);
   }
}

Output ng console: 50 O_О Paano iyon makatuwiran? 1+1. Saan nanggaling ang 50?! Alam mo na na charang mga halaga ay naka-imbak sa memorya bilang mga numero sa hanay mula 0 hanggang 65536, at ang mga numerong ito ay isang Unicode na representasyon ng isang character. Kapag nagdagdag kami ng char at ilang whole-number type, ang char ay mako-convert sa kaukulang Unicode number. Sa aming code, kapag nagdagdag kami ng 1 at '1', ang simbolo na '1' ay na-convert sa sarili nitong code, na 49 (maaari mong i-verify ito sa talahanayan sa itaas). Samakatuwid, ang resulta ay 50. Muli nating kunin ang ating matandang kaibigan na si 耰 bilang isang halimbawa, at subukang idagdag ito sa ilang numero.

public static void main(String[] args) {

   char c = '耰';
   int x = 200;

   System.out.println(c + x);
}

Output ng console: 33016 Natuklasan na namin na ang 耰 ay tumutugma sa 32816. At kapag idinagdag namin ang numerong ito at 200, makukuha namin ang aming resulta: 33016. :) Gaya ng nakikita mo, ang algorithm dito ay medyo simple, ngunit hindi mo ito dapat kalimutan. .