1. Typecasting
Ang mga variable ng primitive na uri (maliban sa boolean
uri) 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:
Uri | Sukat |
---|---|
byte |
1 byte |
short |
2 bytes |
int |
4 bytes |
long |
8 bytes |
Ang variable na nakaimbak sa mas maliliit na basket ay maaaring palaging italaga sa mga variable na nakaimbak sa mas malalaking basket.
int
, short
at byte
ang mga variable ay madaling italaga sa long
mga variable. short
at byte
ang mga variable ay maaaring italaga sa int
mga variable. At byte
ang mga variable ay maaaring italaga sa short
mga variable.
Mga halimbawa:
Code | Paglalarawan |
---|---|
|
Ang code na ito ay mag-compile nang maayos. |
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:
Uri | Sukat |
---|---|
float |
4 bytes |
double |
8 bytes |
float
ang mga variable ay maaaring italaga sa double
mga 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 float
variable. Kahit na ang long
uri, na 8 bytes ang haba. At maaari kang magtalaga ng kahit anong gusto mo — anumang integer variable o float
variable — sa isang double
variable:
Code | Tandaan |
---|---|
|
|
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 long
halaga sa isang int
variable?
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:
Code | Paglalarawan |
---|---|
|
Sa bawat oras na ang operator ng typecast ay dapat na tahasang ipahiwatig |
Narito a
ang katumbas ng 1
, at marahil ang operator ng typecast ay tila labis-labis. Ngunit paano kung a
mas malaki?
Code | Paglalarawan |
---|---|
|
|
Isang milyon ang akma sa isang long
at sa isang int
. Ngunit kapag nagtatalaga ng isang milyon sa isang short
variable, 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:
Uri | Binary notation | Decimal notation |
---|---|---|
int |
0b 00000000 00001111 01000010 01000000 | 1000000 |
short |
0b 01000010 01000000 | 16.960 |
byte |
0b 01000000 | 64 |
char
uri
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 short
uri ay nilagdaan at maaaring maglaman ng mga halaga mula -32,768
sa hanggang +32,767
, ngunit ang char
uri ay hindi nalagdaan at maaaring maglaman ng mga halaga mula 0
sa hanggang 65,535
.
Ang mga negatibong numero ay hindi maiimbak sa isang char
, ngunit maaari silang maiimbak sa isang short
. At ang isang short
hindi 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 int
at a long
ay kasangkot sa isang expression, ang halaga ng int
ay mako-convert sa a long
at pagkatapos lamang magpapatuloy ang operasyon:
Code | Paglalarawan |
---|---|
|
a ay lalawak sa a long at pagkatapos ay magaganap ang karagdagan. |
Mga floating-point na numero
Kung ang isang integer at isang floating-point na numero ( float
o double
) ay kasangkot sa isang expression, ang integer ay mako-convert sa isang floating-point na numero ( float
o double
), at saka lamang isasagawa ang operasyon.
Kung ang operasyon ay nagsasangkot ng a float
at a double
, kung gayon ang float
ay mako-convert sa isang double
. Na talagang inaasahan.
Ang byte
, short
, at char
mga uri ay palaging kino-convert sa int
kapag nakikipag-ugnayan sa isa't isa. Mayroong magandang dahilan kung bakit ang int
uri ay itinuturing na karaniwang uri ng integer.
Kung magpaparami ka ng a byte
sa isang short
, makakakuha ka ng int
. Kung magpaparami ka ng a byte
sa isang byte
, makakakuha ka ng int
. Kahit na magdagdag ka ng byte
at a byte
, makakakuha ka ng int
.
Mayroong ilang mga dahilan para dito. Mga halimbawa:
Code | Paglalarawan |
---|---|
|
110 * 120 ay 13,200 , na bahagyang mas malaki kaysa sa maximum na halaga ng byte uri:127 |
|
110 + 120 ay 230 , na mas malaki rin nang bahagya kaysa sa maximum na halaga ng byte uri:127 |
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 int
palaging agad na kino-convert sa int
s. 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:
Code | Paglalarawan |
---|---|
|
Ang byte * byte ekspresyon ay magiging isangint |
|
Ang byte + byte ekspresyon ay magiging isangint |
|
Ang byte + int expression ay magiging isang int Ang literal ay isang int . |
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:
Code | Paglalarawan |
---|---|
|
Ang operator ng typecast ay ilalapat lamang sa a variable, na isa nang byte . Ang code na ito ay hindi mag-compile. |
|
Ito ang tamang paraan. |
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.
GO TO FULL VERSION