Casting double u int java. Pretvorba tipova u Javi

Ponekad se javljaju situacije kada imate vrijednost određene vrste, a trebate je dodijeliti varijabli drugog tipa. Za neke tipove to se može učiniti bez ulijevanja tipa, u takvim slučajevima se govori o automatskoj pretvorbi tipa. U Javi je automatska konverzija moguća samo kada je numerički prikaz odredišne ​​varijable dovoljno precizan da zadrži izvornu vrijednost. Takva se pretvorba događa, na primjer, kada se literalna konstanta ili vrijednost varijable tipa byte ili short unese u varijablu tipa int. To se zove proširenje (proširenje) ili povećati (promocija), jer se tip manje dubine bita proširuje (podiže) na veći kompatibilni tip. Veličina tipa int uvijek je dovoljno velika za pohranjivanje brojeva iz raspona dopuštenog za tip bajta, dakle in slične situacije nije potreban eksplicitni operator cast. Obrnuto nije točno u većini slučajeva, tako da se mora koristiti cast operator za izlijevanje int vrijednosti u bajt varijablu. Ovaj postupak se ponekad naziva sužavanje (sužavanje), jer izričito govorite prevoditelju da vrijednost treba pretvoriti kako bi se uklopila u varijablu željenog tipa. Da biste doveli vrijednost na određeni tip, prethodite joj tom vrstom zatvorenom u zagradama. Isječak koda u nastavku pokazuje lijevanje izvornog tipa (int varijabla) na odredišni tip (bajt varijabla). Ako bi tijekom takve operacije cjelobrojna vrijednost prešla granice dopuštenog raspona za tip bajta, smanjila bi se modulo dijeljenjem za dopušteni raspon za bajt (rezultat dijeljenja po modulu brojem je ostatak dijeljenja s ovaj broj),

int a = 100;
bajtb = (bajt) a;

2.2.1. Automatska konverzija tipova u izrazima

Prilikom procjene vrijednosti izraza, preciznost potrebna za pohranjivanje međurezultata često mora biti veća od one potrebne za predstavljanje konačnog rezultata,

bajt a = 40;
bajt b = 50;
bajt sa = 100;
int d = a* b / c;

Rezultat srednjeg izraza (a * b) može ići izvan raspona vrijednosti dopuštenih za tip bajta. Zato Java automatski promovira svaki dio izraza da upiše int, tako da ima dovoljno mjesta za srednji rezultat (a*b).

Automatska pretvorba tipa ponekad može uzrokovati neočekivane poruke o grešci kompajlera. Na primjer, kod prikazan u nastavku, iako izgleda sasvim ispravno, rezultira porukom o pogrešci tijekom faze prijevoda. U njemu pokušavamo upisati vrijednost 50 * 2, koja bi se trebala savršeno uklopiti u tip bajta, u bajt varijablu. Ali zbog automatska konverzija Ako je vrsta rezultata int, dobivamo poruku o pogrešci od prevoditelja - uostalom, prilikom pretvaranja int u bajt može doći do gubitka preciznosti.

bajt b = 50;
b = b*2:
^ Nekompatibilan tip za =. Eksplicitno prebacivanje potrebno za pretvaranje int u bajt.
(Nekompatibilan tip za =. Potrebna je eksplicitna konverzijaint tobajt)

Ispravljen tekst:
bajtb = 50;
b = (bajt) (b*2);

što uzrokuje da se b ispuni ispravnom vrijednošću 100.

Ako izraz koristi varijable tipa byte, short i int, tada se tip cijelog izraza automatski promiče u int kako bi se izbjeglo prelijevanje. Ako je tip barem jedne varijable u izrazu dug, tada se tip cijelog izraza također promiče u dug. Zapamtite da su svi cjelobrojni literali koji ne završavaju s L (ili 1) tipa int.

Ako izraz sadrži operande plutajući tip, tada se tip cijelog izraza automatski promiče u float. Ako je barem jedan od operanada tipa double, tada se tip cijelog izraza promovira u double. Java prema zadanim postavkama sve literale s pomičnim zarezom tretira kao tip double. Sljedeći program pokazuje kako se tip svake vrijednosti u izrazu promovira tako da odgovara drugom operandu svakog binarnog operatora.

razred promovira (
public static void main(String args)(
byteb=42;
char with= "a';
kratke hlače = 1024;
int i = 50000;
plovak f = 5,67f;
udvostručeno=.1234;
dvostruki rezultat = (f*b) + (i/ c) - (d* s);
Sustav, van. println ((f* b)+ "+ "+ (i / c)+ "-" + (d* s));
Sustav, van. println("rezultat = "+rezultat); )
}

Podizraz f*b je float pomnožen bajtom, pa se automatski promiče u float. Tip sljedećeg i/c podizraza (int podijeljen sa char) promiče se u int. Slično, podizraz d*s (dvostruko pomnožen kratkim) se promiče u dvostruko. U sljedećem koraku proračuna imamo posla s tri međurezultata tipa float, int i double. Prvo, kada se dodaju prva dva, tip int se promovira u float, a rezultat je float rezultat. Kada se od nje oduzme dvostruka vrijednost, vrsta rezultata se promiče u dvostruku. Konačni rezultat cijelog izraza je dvostruka vrijednost.

Sada kada smo vidjeli sve jednostavne tipove, uključujući cijele brojeve, realne vrijednosti, simbole i logičke vrijednosti, pokušajmo spojiti sve informacije. Primjer u nastavku stvara varijable za svaku od njih jednostavne vrste i prikazuju se vrijednosti ovih varijabli.

klasa SimpleTypes(
public static void main(String args) (
bajt b = 0x55;
kratko s = 0x55ff;
int i = 1000000;
dugo l = 0xffffffffL;
char with= 'a';
float f= .25f;
dvostruki d = .00001234;
boolean bool = istina;
System.out.println("bajt b = " + b);
System.out.println("kratki s = " +s);
System.out.println("int i =" + i);
System.out.println("dugo 1 = " + l);
System.out.println("char with=” + sa);
System.out.println("float f = " + f);
System.out.println("double d = " + d);
System.out.println("boolean bool =" + bool); )
}

Kada pokrenete ovaj program, trebali biste dobiti rezultat prikazan u nastavku:

bajt b = 85
kratke hlače = 22015
int i = 1000000
dugo 1 = 4294967295
char with= a
float f = 0,25
dvostruko d=1.234e-005
boolean bool = istina

Imajte na umu da su cijeli brojevi ispisani u decimalnom zapisu, iako smo neke od njih naveli u heksadecimalnom.

Java je programski jezik jakog tipa, što znači da svaki izraz i svaka varijabla ima jako tipiziran određeni tip već u vrijeme sastavljanja.
Vrste odljevaka
Java nudi sedam vrsta cast:

• Identitet;


• Proširivanje primitivnog tipa (proširivanje primitivnog);


• primitivni tip sužavanja (primitivni sužavanje);


• Proširenje tipa objekta (referenca za proširenje);


• Sužavanje tipa objekta (referenca za sužavanje);


• Pretvori u niz (String);


• Zabranjene konverzije (zabranjene);

Razmotrimo ih zasebno.
Transformacija identiteta
Najjednostavnija je transformacija identiteta. U Javi je pretvaranje izraza bilo koje vrste u potpuno isti tip uvijek legalno i uspješno.
Ovo je važno kako bismo teoretski mogli tvrditi da bilo koji tip u Javi može sudjelovati u pretvorbi, čak i ako je identičan.
Pretvorba primitivnog tipa (proširenje i sužavanje)
Za jednostavne tipove, proširenje znači da se vrši prijelaz s manje prostranog tipa na veći. Na primjer, od tipa byte (duljina 1 bajt) do tipa int (duljina 4 bajta). Takve su transformacije sigurne u smislu da novi tip uvijek jamči da sadrži sve podatke koji su bili pohranjeni u starom tipu, te stoga nema gubitka podataka. Zato ga prevodilac implementira sam, neprimjetno za programera:

byteb=3;
int a=b;

Sljedećih 19 transformacija se širi:

• Od bajta do kratkog, int, dugog, plutajućeg, dvostrukog


• Od kratkog do int, dugog, plutajućeg, dvostrukog


• Od char do int, long, float, double


• Od int do long, float, double


• Od dugog do plutajućeg, dvostrukog


• plutati da se udvostruči

Imajte na umu da ne možete pretvoriti u char iz vrsta manje od ili jednake duljine(bajt, kratko) ili obrnuto na kratko od char bez gubitka podataka. To je zbog činjenice da je char, za razliku od drugih cjelobrojnih tipova, potpisan.
Međutim, treba imati na umu da čak i uz proširenje, podaci i dalje mogu biti iskrivljeni. To su cast od int vrijednosti u float i cast od dugih vrijednosti u float ili double. Iako ove frakcijske vrste mogu primiti mnogo velike brojke od odgovarajućih cijelih brojeva, ali imaju manje značajnih znamenki.
Na primjer:

dugo a = 111111111111L;
float f=a;
a=(dugo)f; // () je samo operacija konverzije tipa
System.out.println(a); //rezultat 111111110656

Obratite pozornost - sužavanje - znači da se prijelaz provodi s većeg tipa na manje prostran. S takvom pretvorbom postoji rizik od gubitka podataka. Na primjer, ako je int bio veći od 127, tada će se prilikom prevođenja u bajt izgubiti bitne vrijednosti starije od osme. U Javi se takva konverzija mora izvršiti eksplicitno, t.j. programer u kodu mora eksplicitno naznačiti da namjerava izvršiti takvu konverziju i da je spreman izgubiti podatke.
Sljedeće 23 transformacije se sužavaju:

• iz bajta u char


• Od kratkog do bajta, char


• Od znaka do bajta, kratko


• Od int do bajta, kratko, char


• Od dugog do bajta, kratko, char, int


• Od float do bajta, kratko, char, int, dugo


• Od dvostrukog do bajta, kratko, char, int, dugo, float

Prilikom sužavanja cjelobrojnog tipa na uži cjelobrojni tip, svi bitovi visokog reda koji se ne uklapaju u novi tip jednostavno se odbacuju. Ne provode se zaokruživanje ili druge radnje kako bi se dobio točniji rezultat:

System.out.println((byte)383);
System.out.println((byte)384);
System.out.println((bajt)-384);

Rezultat će biti:

127
-128
-128
Vidi se da predznačni bit nije imao nikakvog učinka tijekom sužavanja, jer je jednostavno odbačen - rezultat bacanja recipročnih brojeva (384, -384) pokazao se istim. Posljedično, može se izgubiti ne samo točna apsolutna vrijednost, već i predznak količine.
To vrijedi i za char:

char c=4000;
System.out.println((kratko)c);

Proizlaziti:

-25536
Pretvorba referentne vrste (proširivanje i sužavanje)
Pretvorbu tipa objekta najbolje je ilustrirati korištenjem stabla nasljeđivanja. Razmotrimo mali primjer nasljeđivanja:

classParent(
intx;
}

razred ChildY proširuje roditelj (
int y;
}

klasa ChildZ proširuje Parent(
intz;
}

Svaka klasa deklarira polje s jedinstvenim imenom. Ovo polje ćemo smatrati primjerom skupa jedinstvenih svojstava svojstvenih nekom tipu objekta.
Objekti klase Parent imaju samo jedno polje x, što znači da se samo reference tipa Parent mogu odnositi na takve objekte. Objekti klase ChildY imaju polje y i polje x naslijeđeno od klase Parent. Stoga reference tipa ChildY ili Parent mogu upućivati ​​na takve objekte. Primjer:

Roditelj p = newChildY();

Imajte na umu da ova p referenca može pristupiti samo polju x kreiranog objekta. Polje y nije dostupno jer prevodilac, kada provjerava ispravnost p.y izraza, ne može predvidjeti da će referenca p pokazivati ​​na objekt tipa ChildY tijekom izvođenja. Analizira samo tip same varijable i deklarirana je kao Parent, ali ova klasa nema polje y, što će uzrokovati grešku kompilacije.
Slično, objekti klase ChildZ imaju polje z i polje x naslijeđeno od klase Parent. To znači da reference kao što su ChildZ i Parent mogu upućivati ​​na takve objekte.
Dakle, reference tipa Parent mogu upućivati ​​na objekt bilo kojeg od tri razmatrana tipa, dok reference tipa ChildY i ChildZ mogu upućivati ​​samo na objekte potpuno istog tipa. Sada možemo prijeći na pretvaranje referentnih tipova na temelju takvog stabla nasljeđivanja.
Proširenje znači prijeći od specifičnijeg tipa do manje specifičnog tipa, t.j. prijelaz s djece na roditelje. Kao u slučaju sa primitivni tipovi, ovaj prijelaz po potrebi vrši sam JVM i "nevidljiv" je programeru, odnosno ne zahtijeva nikakve posebne transformacije.

Roditelj p1=newChildY();
Roditelj p2=newChildZ();

U oba retka, varijablama tipa Parent dodjeljuje se vrijednost druge vrste, što znači da dolazi do konverzije. Budući da je proširenje, radi se automatski i uvijek uspijeva.
Treba napomenuti da se takvom transformacijom ništa ne događa samom objektu. Unatoč činjenici da, na primjer, polje y klase ChildY više nije dostupno, to ne znači da je nestalo. Ovako značajna promjena objekta nije moguća. Izveden je iz klase ChildY i zadržava sva svoja svojstva. Promijenio se samo tip veze preko koje se pristupa objektu.
Obrnuti prijelaz, odnosno spuštanje niz stablo nasljeđivanja do nasljednika, je sužavanje. Na primjer, u ovom slučaju, prijelaz s reference tipa Parent , koja se može odnositi na objekte triju klasa, na referencu tipa ChildY, koja se može odnositi samo na jednu od tri klase, očito je sužavanje. Takav prijelaz možda neće biti moguć. Ako se referenca tipa Parent odnosi na objekt tipa Parent ili ChildZ, tada je prijelaz na ChildY nemoguć, jer u oba slučaja objekt nema polje y, koje je deklarirano u klasi ChildY. Stoga, prilikom sužavanja, programer treba eksplicitno naznačiti da je potrebno pokušati provesti takvu transformaciju. JVM će provjeriti ispravnost prijelaza tijekom izvođenja. Ako je moguće, pretvorba će se izvršiti. Ako nije, pojavit će se pogreška (obično ClassCastException).

Roditelj p=newChildY();
ChildYcy = (ChildY)p; //pravo
Roditelj p2=newChildZ();
ChildYcy2 = (ChildY)p2; //pogreška

Da biste provjerili je li željeni prijelaz moguć, možete koristiti instanceof operator:

Roditelj p=newChildY();
if (p instanceofChildY)(
ChildYcy = (ChildY)p;
}

Roditelj p2=newChildZ();
if (p2 instanceof ChildY) (
ChildYcy = (ChildY)p2;
}

Roditelj p3=novi roditelj();
if (p3 instanceofChildY)(
ChildYcy = (ChildY)p3;
}

V ovaj primjer neće se pojaviti greške. Prva transformacija je moguća i bit će provedena. U drugom i trećem slučaju uvjeti if naredbi neće funkcionirati i stoga neće biti pogrešnog prijelaza.
Pretvori u niz
Bilo koja vrsta može se baciti na niz, t.j. na primjer klasa String. Takva je konverzija iznimna zbog činjenice da pokriva apsolutno sve vrste.
Različite vrste se pretvaraju u niz na sljedeći način:

• Numerički tipovi su upisani tekstualni oblik bez gubitka točnosti reprezentacije. Prvo, na temelju primitivne vrijednosti, generira se instanca odgovarajuće klase “wrapper”, a zatim se na njoj poziva metoda toString(). No budući da su te radnje nevidljive izvana, JVM ih optimizira i pretvara primitivne vrijednosti izravno slati tekst.


• Booleove vrijednosti se pretvaraju u niz "true" ili "false" ovisno o vrijednosti.


• Za vrijednosti objekata poziva se metoda toString(). Ako metoda vrati null, tada će rezultat biti niz "null".


• Za null vrijednost generira se niz "null".

Zabranjene konverzije
Nisu dopušteni svi prijelazi između proizvoljnih tipova. Na primjer, zabranjene pretvorbe uključuju: prijelaze s bilo kojeg referentnog tipa na primitivni i obrnuto (osim pretvorbe u niz), boolean se može baciti samo na ovu vrstu ili na niz. Osim toga, nemoguće je međusobno dovesti klase koje se nalaze na susjednim granama stabla nasljeđivanja. U primjeru, za koji se smatralo da ilustrira referentne tipove, prijelaz iz ChildY u ChildZ je zabranjen.
Ovaj popis zabranjenih transformacija nije iscrpljen. Prilično je širok, a istodobno su sve opcije prilično očite, tako da se neće detaljno razmatrati. Oni koji žele mogu dobiti pune informacije iz specifikacije.
Naravno, pokušaj izvođenja zabranjene konverzije će uzrokovati pogrešku.

Korištenje odljevaka
Situacije konverzije vrsta mogu se grupirati na sljedeći način:

• Dodjela vrijednosti varijablama (dodjela). Nisu svi prijelazi dopušteni pod takvom transformacijom - ograničenja su odabrana na način da se ne može dogoditi iznimka.


• Poziv metode. Ova se pretvorba primjenjuje na argumente pozvane metode ili konstruktora. Takav cast nikada ne stvara pogreške. Casting se također provodi prilikom vraćanja vrijednosti metode.


• Eksplicitna glumačka postava. U ovom slučaju, izričito je navedeno na koji tip želite baciti izvornu vrijednost.


• Operator spajanja pretvara u niz svojih argumenata.


• Brojčano proširenje. Numeričke operacije može zahtijevati promjenu vrste argumenata. Ova transformacija ima poseban naziv - proširena, od izbora tip cilja može ovisiti ne samo o početnoj vrijednosti, već i o drugom argumentu operacije.

Zadatak #8
Dodajte projektu korištenje cast za svoju hijerarhiju razreda.

Ponekad se javljaju situacije kada je potrebno dodijeliti vrijednost varijabli jedne vrste varijabli drugog tipa. Na primjer:

Primjer 1: Dodjela vrijednosti varijabli jedne vrste drugoj

int i = 11; bajt b = 22; i = b;

Postoje 2 vrste transformacija u Javi - automatska konverzija (implicitna) i određivanje tipa (eksplicitna konverzija).

1. Automatska konverzija

Razmotrite prvu automatsku pretvorbu. Ako su obje vrste kompatibilne, Java će automatski izvršiti njihovu konverziju. Na primjer, vrijednost poput bajt uvijek se može dodijeliti varijabli tipa int , kao što je prikazano u primjeru 1.

Za automatsku pretvorbu tipa moraju biti ispunjena dva uvjeta:

• obje vrste moraju biti kompatibilne
• duljina tipa cilja mora biti veća od duljine početni tip

U ovom slučaju to se događa ekspanzijska konverzija.

Sljedeći dijagram prikazuje konverziju proširenja u Javi:

Pune linije označavaju pretvorbe izvršene bez gubitka podataka. Isprekidane linije označavaju da tijekom pretvorbe može doći do gubitka preciznosti.

Na primjer, tip podataka int uvijek dovoljno velik da sve primi dopuštene vrijednosti tip bajt , tako da nema eksplicitnih operatora cast ovaj slučaj nije obavezno. U smislu pretvorbe proširenja, numerički tipovi podataka, uključujući cijeli broj i pokretni zarez, međusobno su kompatibilni. Istodobno, nema automatske konverzije brojčanih vrsta u tip čar ili boolean . Vrste čar i boolean također međusobno nespojive.

Vrijedi malo objasniti zašto, na primjer, tip bajt se ne pretvara automatski (implicitno) u tip čar , iako tip bajt je širok 8 bita, i čar - 16, isto vrijedi i za pretvorbu tipa kratak v čar . To se događa jer bajt i kratak potpisane vrste podataka, i čar nepotpisan. Stoga, u ovom slučaju, trebate koristiti eksplicitno uvođenje tipa, budući da prevodilac mora eksplicitno naznačiti da znate što želite i kako će se bit znakova tipova obraditi bajt i kratak prilikom pretvaranja u tip čar .

Vrsta Vrijednost Ponašanje čar u većini slučajeva je isto kao i ponašanje cjelobrojne vrijednosti tipa, dakle vrijednost tipa čar može se koristiti gdje god su potrebne vrijednosti int ili dugo . Međutim, podsjećamo da je tip čar nije predznak, pa se ponaša drugačije od tipa kratak , iako je raspon obje vrste 16 bita.

2. Casting

Unatoč svim pogodnostima automatske pretvorbe tipa, nije u mogućnosti zadovoljiti sve hitne potrebe. Na primjer, što ako vrijednost tipa int mora biti dodijeljen varijabli tipa bajt ? Ova se pretvorba neće izvršiti automatski zbog duljine vrste bajt manje od tipa int . Ponekad se ovakva transformacija naziva sužavanje transformacije, budući da je vrijednost jasno sužena kako bi se uklopila u ciljni tip podataka.

Da biste pretvorili dvije nekompatibilne vrste podataka, morate koristiti cast. Cast je samo eksplicitna konverzija tipa. Opći oblik odljevak tipa ima sljedeći oblik:

(ciljni_tip) vrijednost

gdje parametar cilj_vrste označava tip u koji se navedena vrijednost treba pretvoriti.

Primjer 2: Lijevanje

Na primjer, u sljedećem isječku koda upišite int baciti na tip bajt:

Int i = 11; bajt b = 22; b = (bajt)i;

Primjer 3: Pretvaranje vrijednosti s pomičnim zarezom u cijele brojeve

Pogledajmo primjer pretvaranja vrijednosti s pomičnim zarezom u cijele brojeve. U ovom primjeru frakcija vrijednosti s pomičnim zarezom jednostavno se odbacuju (operacija skraćivanja):

Dvostruki d = 3,89; int a = (int) d; //Rezultat će biti 3

Primjer 4: Pretvaranje većeg cjelobrojnog tipa u manji cjelobrojni tip

Prilikom pretvaranja većeg cjelobrojnog tipa u manje opsežni cjelobrojni tip, visoki bitovi se jednostavno odbacuju:

int i = 323; bajt b = (bajt) i; //Rezultat će biti 67

Primjer 5: Pretvaranje većeg broja s plutanjem u manji cijeli broj

Prilikom dovođenja veće vrijednosti s pomičnim zarezom na cijeli broj, najznačajniji bitovi se skraćuju i odbacuju:

Dvostruki d = 389889877779,89; kratko s = (kratko) d; //Rezultat će biti -1

3. Automatska promocija tipova u izrazima

Osim operacija dodjeljivanja, određene pretvorbe tipa mogu se izvesti i u izrazima.

V Java jezik vrijede sljedeća pravila:

1. Ako je jedan operand tipa dvostruko dvostruko.
2. plutati, drugi se također pretvara u tip plutati.
3. Inače, ako je jedan operand tipa dugo, drugi se također pretvara u tip dugo.
4. Inače se oba operanda pretvaraju u tip int.
5. Kombinirane izraze dodjeljivanja (+=,-=,*=,/=) nije potrebno ubaciti.

Evo primjera:

Primjer 6: Automatska promocija tipa u izrazima

Prilikom množenja varijable b1 ( bajt) na 2 ( int) rezultat će biti kao int. Stoga, kada pokušavate dodijeliti rezultat varijabli b2 ( bajt) će generirati pogrešku kompilacije. Ali kada se koristi kombinirani operator dodjeljivanja (*=), ovaj problem se ne pojavljuje.

Bajt b1 = 1; bajt b2 = 2 * b1; //Greška kompilacije int i1 = 2 * b1; b2 *= 2;

Primjer 7: Automatska promocija tipa u izrazima

V sljedeći primjer također će doći do pogreške u kompilaciji – unatoč činjenici da su brojevi poput bajt, rezultat operacije bit će tip int, ali ne kratak.

Javna klasa IntegerDemo1 (javni statički void main(String args) (bajt b1 = 50, b2 = -99; kratki k = b1 + b2; //pogreška kompajliranja System.out.println("k=" + k); ) )

Primjer 8: Automatska promocija tipa u izrazima

Ovaj primjer je sličan prethodnom, ali se koristi kombinirana operacija dodjele, u kojoj se cast događa automatski.

Javna klasa IntegerDemo2 (javni statički void main(String args) (bajt b1 = 50, b2 = -99; b1 += b2; System.out.println("b1=" + b1); ) )

1. Što je eksplicitno i automatsko lijevanje vrste u izrazima?

Liječenje tipa može biti eksplicitno ili automatsko.

S eksplicitnim lijevanjem tipa, sama operacija lijevanja je eksplicitno specificirana.

Za automatsko lijevanje potrebno je ispuniti dva uvjeta:

• obje vrste moraju biti kompatibilne;
• duljina izvornog tipa (vrsta izvora) mora biti manja od duljine ciljnog tipa (vrsta odredišta).

2. Kako izgleda eksplicitno uvođenje tipova u izrazima? Primjeri

Eksplicitno uvođenje tipova omogućuje dodjelu nekompatibilnih tipova. Opći oblik eksplicitnog ulijevanja tipa je:

(ciljni_tip) vrijednost

cilj_vrste je tip na koji želite baciti navedeni značenje.

Primjeri eksplicitna konverzija tipa.

// eksplicitno uvođenje tipa u izraze bajt b; int a; dvostruko d; plutati f; d = -39,9203; a = (int)d; // a = -39 f = (float)d; // f = -39,9203 b = (bajt) d; // b = -39 d = 302930932; b = (bajt) d; // b = -12 - skraćivanje vrijednosti a = -27; b = (bajt)a; // b = -27

3. Primjeri automatskog lijevanja

Primjer 1. Automatsko lijevanje integralnih tipova.

// automatsko lijevanje integralnih tipova int a; bajt b; kratko sh; b = -23; a = b; // a = -23 - automatsko lijevanje tipa sh = -150; a = sh; // a = -150 dugo l = 200; // Pogreška: "Nepodudaranje vrste: ne može se pretvoriti iz long u int" // a = l; l = b; // l = -23 l = sh; // l = -150 char c = "Z"; a = c; // a = 90 - znakovni kod "Z" boolean b1 = lažno; //a = b1; - pogreška, vrste su nekompatibilne

Primjer 2. Automatsko lijevanje tipova s ​​pomičnim zarezom.

// automatsko lijevanje u pokretni zarez plutati f; dvostruko d; f = 3,409033f; d = f; // d = 3,409033

Primjer 3. Automatsko lijevanje mješoviti tipovi. Takav je slučaj moguć ako se varijabli tipa s pomičnim zarezom dodijeli vrijednost varijable cjelobrojnog tipa.

// automatska konverzija mješovitih tipova plutati f; dvostruko d; a = 28; d = a; // d = 28,0 f = a; // f = 28,0 // Pogreška: nepodudaranje tipa: ne može se pretvoriti iz float u int // a = f;

4. Kako se provodi automatska promocija tipa u izrazima?

Automatska promocija vrste se javljaju u izrazima. U ovom slučaju, vrijednost koja se pojavljuje u izrazima automatski se promiče u vrste s velikim rasponima vrijednosti.

Prilikom automatskog promoviranja vrsta u izrazima:

• ako je jedan od cjelobrojnih operanda tipa int, tada se sve vrijednosti byte, short i char promoviraju u tip int;
• ako je jedan od cjelobrojnih operanda tipa long, tada se cijeli izraz promovira u tip long;
• ako je jedan od operanada tipa float, tada će i tip cijelog izraza biti tipa float (ako nema operanda tipa double);
• ako je jedan od operanada tipa double, tada će i tip cijelog izraza biti double.

5. Primjer promocije s tipa byte na int u kojem izraz ne sadrži operande-varijable tipa int (long)

// bajt -> int bajt b; b = 1000 / 20; // b = 50, radi jer se rezultat stavlja u bajt

Gornji primjer radi ispravno jer:

• rezultat se stavlja (kompatibilan) u tip bajta;
• nema operanda tipa int.

U gornjem primjeru, vrijednost 1000 premašuje raspon vrijednosti bajtova. Prvo, broj 1000 se baca na tip int. Ali rezultat

1000 / 20 = 50

se prebacuje na bajt tipa i može ispravno stati u varijablu b .

Ako ovako napišeš:

bajt b; b = 100000 / 20; // pogreška jer se rezultat ne uklapa u tip bajta

tada će se pojaviti pogreška kompilacije sa sljedećom porukom:

U ovom slučaju, rezultat se ne uklapa u tip bajta:

100000 / 20 = 5000

Tada ovaj broj (5000) automatski postaje int tip i prevodilac će izdati poruku o pogrešci.

Ako radite eksplicitni tip:

bajt b; b = (bajt) (100000 / 20); // b = -120

tada se u ovom slučaju rezultat 5000 tipa int pretvara u bajt tipa. Kao što znate, varijabla int zauzima 32 bita, a varijabla tipa bajta 8 bita. Vrijednost varijable tipa int je skraćena. I imamo ono što imamo (b = -120).

Gore navedeni primjeri odnose se na varijable tipa kratki i char.

6. Primjer. Promocija s tipa byte na tip int, u kojem izraz sadrži varijabilni operand tipa int

// promicanje tipova u izrazima // bajt -> int bajt b; int d; d=20; // pogreška, rezultat je tipa int, budući da je varijabla d tipa int // b = 1000 / d;

U gornjem primjeru izraz koristi varijablu d tipa int. Stoga će prevodilac dati poruku o pogrešci:

Nepodudarnost tipa: ne može se pretvoriti iz int u bajt

To znači da je rezultat tipa int (ne byte ) čak i ako vrijednost odgovara rasponu vrijednosti bajta. Budući da izraz koristi promjenjivi operand d upišite int.

Ako implementirate eksplicitnu konverziju tipa, rezultat će biti točan:

// promicanje tipova u izrazima // bajt -> int bajt b; int d; d=20; b = (bajt) (1000 / d); // b = 50 - radi ispravno

7. Primjer. Promocija od tipa int do tipa long

Primjer promocije tipa iz int u long. Ako je jedan od operanada tipa long, tada se cijeli izraz promovira u tip long.

int d; longl; d = 10000 * 200; // radi, d = 2000000 // Greška! Nepodudaranje tipa: ne može se pretvoriti iz long u int // d = 1L * 2L; - operandi 1L i 2L su tipa long l = 100; // pogreška, jedan od operanada je tipa long // d = l * 2;

Kao što možete vidjeti iz primjera, ako je jedan od operanada tipa long, tada cijeli izraz postaje tipa long.