Pag-cast (pag-convert) ng mga primitive na uri sa Java

Kamusta! Habang dumadaan sa JavaRush, nakatagpo ka ng mga primitive na uri nang higit sa isang beses. Narito ang isang maikling listahan ng kung ano ang alam namin 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 ng primitive na uri:
   • Buong mga numero - byte, short, int,long
   • Mga numero ng floating point (fractional) - floatatdouble
   • Boolean -boolean
   • Simboliko (upang ipahiwatig ang mga titik at numero) -char
3. Ang bawat isa sa kanila ay may sariling hanay ng mga halaga:

Ngunit, bilang karagdagan sa mga halaga, ang mga uri ay naiiba din sa laki ng memorya. inttumatagal ng higit sa byte. A long- higit sa short. Ang dami ng memorya na inookupahan ng mga primitive ay maihahambing sa mga nesting doll: May libreng espasyo sa loob ng nesting doll. Kung mas malaki ang pugad na manika, mas maraming espasyo. longMadali nating mailalagay ang mas maliit sa loob ng malaking nesting doll int. Madali itong magkasya at hindi mo kailangang gumawa ng anumang bagay. Sa Java, kapag nagtatrabaho sa mga primitive, ito ay tinatawag na awtomatikong conversion. Sa ibang paraan ito ay tinatawag na extension. Narito ang isang simpleng halimbawa ng extension:

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 halaga bytesa isang variable int. Ang pagtatalaga ay matagumpay at walang anumang mga problema: ang halaga na nakaimbak sa ay bytesumasakop sa mas kaunting espasyo ng memorya kaysa sa "kasya" nito sa int. Ang "maliit na nesting doll" (value byte) ay madaling magkasya sa "malaking matryoshka" (variable int). Isa pang bagay kapag sinubukan mong gawin ang kabaligtaran - maglagay ng malaking halaga sa isang variable na hindi idinisenyo para sa mga ganoong laki. Sa prinsipyo, ang lansihin na ito ay hindi gagana sa mga totoong nesting na manika, ngunit sa Java ito ay gagana, ngunit may mga nuances. Subukan nating maglagay ng value intsa isang variable short:

public static void main(String[] args) {

   int bigNumber = 10000000;

   short littleNumber = 1000;

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

Error! Naiintindihan ng compiler na sinusubukan mong gumawa ng isang bagay na hindi karaniwan, at maglagay ng malaking matryoshka doll ( int) sa loob ng maliit ( short). Ang isang error sa compilation sa kasong ito ay isang babala mula sa compiler: " Uy, sigurado ka bang gusto mong gawin ito? "Kung sigurado ka, sabihin sa compiler ang tungkol dito: " Okay ang lahat, alam ko kung ano ang ginagawa ko!" ” Ang prosesong ito ay tinatawag na tahasang uri ng conversion, o pagpapaliit . Upang gumawa ng pagpapaliit, kailangan mong tahasang ipahiwatig ang uri kung saan mo gustong i-cast ang iyong halaga. Sa madaling salita, sagutin ang tanong ng compiler: " Buweno, alin sa maliliit na manika na ito ang gusto mong ilagay ang malaking manika na ito?" ” Sa aming kaso, magiging ganito:

public static void main(String[] args) {

   int bigNumber = 10000000;

   short littleNumber = 1000;

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

Malinaw naming ipinahiwatig na gusto naming magkasya ang halaga intsa isang variable shortat managot para dito. Ang compiler, na nakikita ang isang tahasang indikasyon ng isang mas makitid na uri, ay nagsasagawa ng isang conversion. Ano ang magiging resulta? Output ng console: -27008 Medyo hindi inaasahan. Bakit ganito talaga? Ito ay talagang simple. Mayroon kaming orihinal na halaga - 10000000 Naimbak ito sa isang variable intna umabot ng 32 bits, at sa binary form ay ganito ang hitsura: Isinulat namin ang halagang ito sa variable short, ngunit maaari lamang itong mag-imbak ng 16 bits! Alinsunod dito, ang unang 16 bits lamang ng aming numero ang ililipat doon, ang natitira ay itatapon. Bilang resulta, ang variable shortay maglalaman ng halaga , na sa decimal na anyo ay eksaktong katumbas ng -27008 Iyon ang dahilan kung bakit ang compiler ay "humingi ng kumpirmasyon" sa anyo ng isang tahasang cast 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 nag-cast ng mga uri. Pagkatapos ng lahat, kung sa huling halimbawa ay nag-cast kami intupang mag-type byte, at hindi sa short, magkakaroon lamang kami ng 8 bits sa aming pagtatapon, hindi 16, at ang resulta ay magiging iba. Para sa mga fractional na uri ( floatat double), iba ang nangyayari sa pagpapaliit. Kung susubukan mong i-convert ang naturang numero sa isang uri ng integer, ang fractional na bahagi nito ay itatapon.

public static void main(String[] args) {

   double d = 2.7;

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

Output ng console: 2

Uri ng data char

Alam mo na na ang uri ng 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 mayroon itong isang bilang ng mga tampok na mahalagang maunawaan. Tingnan natin muli ang talahanayan na may mga hanay ng halaga: Ang uri charay may numeric range mula 0 hanggang 65536. Ngunit ano ang ibig sabihin nito? Pagkatapos ng lahat, charang mga ito ay hindi lamang mga numero, kundi pati na rin mga titik, mga marka ng bantas... Ang katotohanan ay ang mga halaga charay nakaimbak sa Java sa Unicode na format. Nakatagpo na tayo ng Unicode sa isa sa mga nakaraang lecture. Marahil ay naaalala mo na ang Unicode ay isang pamantayan sa pag-encode ng character na kinabibilangan ng mga character mula sa halos lahat ng nakasulat na wika sa mundo. Sa madaling salita, ito ay isang listahan ng mga espesyal na code kung saan mayroong isang code para sa halos anumang character mula sa anumang wika. Ang pangkalahatang talahanayan ng Unicode ay napakalaki at, siyempre, ay hindi kailangang matutunan sa pamamagitan ng puso. Narito, halimbawa, ang isang piraso nito: Ang pangunahing bagay ay upang maunawaan ang prinsipyo ng pag-iimbak ng mga halaga char, at tandaan na ang pag-alam sa code ng isang tiyak na simbolo, maaari mong palaging makuha ito sa programa. Subukan natin ito gamit ang 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 kung saan iniimbak ang mga character sa Java char. Ang bawat karakter ay tumutugma sa isang numero - isang numeric code na 16 bits, o dalawang byte. Ang Unicode 32816 ay tumutugma sa karakter na 耰. Bigyang-pansin ang sandaling ito. Sa halimbawang ito ginamit namin ang variable int. Sinasakop nito ang 32 bits ng memorya , habang char16 . Dito namin pinili dahil ang numero na kailangan namin, 32816, ay wala sa saklaw . Bagama't ang laki , tulad ng maikli, ay 16 bits, walang mga negatibong numero sa hanay, kaya ang "positibong" hanay ay dalawang beses na mas malaki (65536 sa halip na 32767 ). Magagamit namin ang , hangga't ang aming code ay nasa saklaw na 65536. Ngunit kung gagawa kami ng numero , aabutin ito ng higit sa 16 bits. At kapag pinaliit ang mga uri: intshortcharcharcharshortintint >65536

char c = (char) x;

ang mga dagdag na piraso ay itatapon, at ang resulta ay magiging hindi inaasahan.

Mga tampok ng pagdaragdag ng char at integer

Tingnan natin ang hindi pangkaraniwang halimbawang ito:

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_O Nasaan ang lohika? 1+1, saan nanggaling ang 50?! Alam mo na na ang mga halaga charay nakaimbak sa memorya bilang mga numero sa hanay mula 0 hanggang 65536, na kumakatawan sa Unicode ng ating karakter. Kaya eto na. Kapag nagsagawa kami ng karagdagan charat ang ilang uri ng integer charay na-convert sa numero na tumutugma dito sa Unicode. Kapag sa aming code ay nagdagdag kami ng 1 at '1', ang simbolo na '1' ay binago sa code nito, na 49 (maaari mong suriin ito sa talahanayan sa itaas). Samakatuwid, ang resulta ay naging katumbas ng 50. Muli nating kunin ang ating dating kaibigan -耰bilang isang halimbawa , at subukang idagdag ito ng ilang numero.

public static void main(String[] args) {

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

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

Output ng console: 33016 Nalaman na namin na ang耰ay tumutugma sa code 32816. At kapag idinagdag namin ang numerong ito at 200, eksaktong makukuha namin ang aming resulta - 33016 :) Ang mekanismo ng operasyon, tulad ng nakikita mo, ay medyo simple.