Typecasting sa Java

1. Typecasting

Ang mga variable ng primitive na uri (maliban sa booleanuri) ay ginagamit upang mag-imbak ng iba't ibang uri ng mga numero. Kahit na ang mga uri ng mga variable ay hindi kailanman nagbago, mayroong isang lugar kung saan maaari kang mag-convert mula sa isang uri patungo sa isa pa. At ang lugar na iyon ay assignment .

Ang mga variable ng iba't ibang uri ay maaaring italaga sa bawat isa. Kapag ginawa mo ito ang halaga ng isang variable ng isang uri ay mako-convert sa isang halaga ng isa pang uri at itinalaga sa pangalawang variable. Kaugnay nito, matutukoy natin ang dalawang uri ng conversion ng uri: pagpapalawak at pagpapaliit.

Ang pagpapalawak ay tulad ng paglipat ng isang halaga mula sa isang maliit na basket patungo sa isang malaki: ang operasyong ito ay walang putol at walang sakit. Nangyayari ang pagpapaliit kapag inilipat mo ang isang halaga mula sa isang malaking basket patungo sa isang maliit: maaaring walang sapat na espasyo, at kailangan mong itapon ang isang bagay.

Narito ang mga uri, pinagsunod-sunod ayon sa laki ng basket:

2. Pagpapalawak ng mga uri ng conversion

Kadalasang kinakailangan na magtalaga ng variable ng isang uri ng numero sa isang variable ng isa pang uri ng numero. Paano mo gagawin iyon?

Ang Java ay may 4 na uri ng integer:

Ang variable na nakaimbak sa mas maliliit na basket ay maaaring palaging italaga sa mga variable na nakaimbak sa mas malalaking basket.

int, shortat byteang mga variable ay madaling italaga sa longmga variable. shortat byteang mga variable ay maaaring italaga sa intmga variable. At byteang mga variable ay maaaring italaga sa shortmga variable.

Mga halimbawa:

byte a = 5;
short b = a;
int c = a + b;
long d = c * c;

Ang nasabing conversion, mula sa mas maliit hanggang sa mas malaking uri, ay tinatawag na widening type conversion.

Paano ang tungkol sa mga tunay na numero?

Sa kanila, ang lahat ay pareho - mahalaga ang laki:

floatang mga variable ay maaaring italaga sa doublemga variable nang walang anumang mga problema. Ngunit ang mga bagay ay mas kawili-wili sa mga uri ng integer.

Maaari kang magtalaga ng anumang integer variable sa isang floatvariable. Kahit na ang longuri, na 8 bytes ang haba. At maaari kang magtalaga ng kahit anong gusto mo — anumang integer variable o floatvariable — sa isang doublevariable:

long a = 1234567890;
float b = a;
double c = a;

b == 1.23456794E9
c == 1.23456789E9

Tandaan na ang pag-convert sa isang tunay na uri ay maaaring magresulta sa pagkawala ng katumpakan dahil sa kakulangan ng sapat na makabuluhang mga digit.

Kapag nagko-convert mula sa mga integer patungo sa mga floating-point na numero, ang mga mas mababang bahagi ng pagkakasunud-sunod ng mga numero ay maaaring itapon. Ngunit dahil ang mga fractional na numero ay nauunawaan na nag-iimbak ng mga tinatayang halaga, ang mga naturang pagpapatakbo ng pagtatalaga ay pinahihintulutan.

3. Pagpapaliit ng mga uri ng conversion

Paano ang iba pang mga posibilidad? Paano kung kailangan mong magtalaga ng longhalaga sa isang intvariable?

Isipin ang isang variable bilang isang basket. Mayroon kaming mga basket na may iba't ibang laki: 1, 2, 4 at 8 bytes. Hindi problema ang paglipat ng mga mansanas mula sa isang mas maliit na basket patungo sa isang mas malaki. Ngunit kapag lumipat mula sa isang mas malaking basket patungo sa isang mas maliit, ang ilan sa mga mansanas ay maaaring mawala.

Ang pagbabagong ito — mula sa isang mas malaking uri patungo sa isang mas maliit na uri — ay tinatawag na isang narrowing type na conversion . Kapag nagsasagawa ng pagpapatakbo ng pagtatalaga na tulad nito, maaaring hindi magkasya ang bahagi ng isang numero sa bagong variable at samakatuwid ay maaaring itapon.

Kapag nagpapaliit ng isang uri, dapat nating tahasang sabihin sa compiler na hindi tayo nagkakamali, na sadyang itinatapon natin ang bahagi ng numero. Ginagamit ang typecast operator para dito. Ito ay isang uri ng pangalan sa panaklong .

Sa ganitong mga sitwasyon, ang Java compiler ay nangangailangan ng programmer na tukuyin ang typecast operator. Sa pangkalahatan, ganito ang hitsura:

(type) expression

Mga halimbawa:

long a = 1;
int b = (int) a;
short c = (short) b;
byte d = (byte) c;

Narito aang katumbas ng 1, at marahil ang operator ng typecast ay tila labis-labis. Ngunit paano kung amas malaki?

long a = 1000000;
int b = (int) a;
short c = (short) b;
byte d = (byte) c;

a == 1000000
b == 1000000
c == 16960
d == 64

Isang milyon ang akma sa isang longat sa isang int. Ngunit kapag nagtatalaga ng isang milyon sa isang shortvariable, ang unang dalawang byte ay itatapon, at ang huling dalawang byte lamang ang pananatilihin. At kapag nagtalaga sa isang byte, ang tanging natitira ay ang huling byte.

Paano nakaayos ang mga numero sa memorya:

charuri

Ang A char, tulad ng a short, ay sumasakop ng dalawang byte, ngunit para ma-convert ang isa sa isa, kailangan mong laging gumamit ng typecast operator. Ang isyu dito ay ang shorturi ay nilagdaan at maaaring maglaman ng mga halaga mula -32,768sa hanggang +32,767, ngunit ang charuri ay hindi nalagdaan at maaaring maglaman ng mga halaga mula 0sa hanggang 65,535.

Ang mga negatibong numero ay hindi maiimbak sa isang char, ngunit maaari silang maiimbak sa isang short. At ang isang shorthindi maaaring mag-imbak ng mga numerong mas malaki kaysa sa 32,767, ngunit ang mga naturang numero ay maaaring maimbak sa isang char.

4. Uri ng pagpapahayag

Paano kung ang mga variable ng iba't ibang uri ay ginagamit sa parehong expression? Logically, naiintindihan namin na kailangan muna nilang i-convert sa isang karaniwang uri. Ngunit alin?

Sa mas malaki, siyempre.

Palaging nagko-convert ang Java sa mas malaking uri. Sa halos pagsasalita, ang isa sa mga uri ay unang pinalawak at pagkatapos lamang ay isinasagawa ang operasyon gamit ang mga halaga ng parehong uri.

Kung ang isang intat a longay kasangkot sa isang expression, ang halaga ng intay mako-convert sa a longat pagkatapos lamang magpapatuloy ang operasyon:

int a = 1;
long b = 2;
long c = a + b;

Mga floating-point na numero

Kung ang isang integer at isang floating-point na numero ( floato double) ay kasangkot sa isang expression, ang integer ay mako-convert sa isang floating-point na numero ( floato double), at saka lamang isasagawa ang operasyon.

Kung ang operasyon ay nagsasangkot ng a floatat a double, kung gayon ang floatay mako-convert sa isang double. Na talagang inaasahan.

Kung magpaparami ka ng a bytesa isang short, makakakuha ka ng int. Kung magpaparami ka ng a bytesa isang byte, makakakuha ka ng int. Kahit na magdagdag ka ng byteat a byte, makakakuha ka ng int.

Mayroong ilang mga dahilan para dito. Mga halimbawa:

byte a = 110;
byte b = 120;
byte c = a * b;  // Error

byte a = 110;
byte b = 120;
byte c = a + b; // Error

Sa pangkalahatan, kapag nagpaparami ng 8-bit (1 byte) na numero sa isang 8-bit (1 byte) na numero, nakakakuha kami ng numero na sumasakop sa 16-bits na bits (2 byte)

Bilang resulta, ang lahat ng mga pagpapatakbo na may mga uri ng integer na mas maliit kaysa sa intpalaging agad na kino-convert sa ints. At nangangahulugan iyon na kung gusto mong iimbak ang resulta ng pagkalkula sa isang variable ng isang uri na mas maliit kaysa sa isang int, pagkatapos ay palaging kailangan mong tahasang tukuyin ang operator ng typecast.

Mga halimbawa:

byte a = 110;
byte b = 120;
byte c = (byte) (a * b);

byte a = 110;
byte b = 120;
byte c = (byte) (a + b);

byte a = 1;
byte b = (byte) (a + 1);

5. Isang mahalagang nuance

Ang operator ng typecast ay may medyo mataas na priyoridad.

Nangangahulugan iyon na kung ang isang expression ay naglalaman, halimbawa, karagdagan at isang typecast operator, ang typecast ay isasagawa bago ang karagdagan.

Halimbawa:

byte a = 1;
byte b = 2;
byte c = (byte) a * b;

byte a = 1;
byte b = 2;
byte c = (byte) (a * b);

Kung gusto mong i-convert ang buong expression sa isang partikular na uri, at hindi lamang isang bahagi ng expression, pagkatapos ay balutin ang buong expression sa mga panaklong at ilagay ang typecast operator sa harap.