Casting double u int java. Konverzija tipova u Javi

Ponekad se javljaju situacije kada imate vrijednost određenog tipa, a trebate je dodijeliti varijabli drugog tipa. Za neke tipove to se može učiniti bez prelijevanja tipa, u takvim slučajevima se govori o automatskoj konverziji tipa. U Javi, automatska konverzija je moguća samo kada je numerički prikaz odredišne ​​varijable dovoljno precizan da zadrži originalnu vrijednost. Takva konverzija se 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 je uvijek dovoljno velika za pohranjivanje brojeva iz raspona dozvoljenog za tip bajta, dakle in slične situacije nije potreban eksplicitni operator cast. Obrnuto nije tačno u većini slučajeva, tako da se mora koristiti cast operator za bacivanje int vrijednosti u bajt varijablu. Ova procedura se ponekad naziva sužavanje (sužavanje), jer izričito govorite prevodiocu da vrijednost treba konvertirati kako bi se uklopila u varijablu željenog tipa. Da biste doveli vrijednost na određeni tip, prethodite mu tim tipom u zagradama. Isječak koda ispod pokazuje pretvaranje izvornog tipa (int varijabla) u odredišni tip (bajt varijabla). Ako bi tokom takve operacije vrijednost cijelog broja bila izvan raspona dozvoljenog za tip bajta, ona bi se smanjila modulo dijeljenjem za dozvoljeni raspon za bajt (rezultat modulo dijeljenja brojem je ostatak dijeljenja ovim brojem) ,

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

2.2.1. Automatska konverzija tipova u izrazima

Kada se procjenjuje vrijednost 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 dozvoljenih za tip bajta. Zato Java automatski promoviše svaki dio izraza da otkuca int, tako da ima dovoljno mjesta za srednji rezultat (a*b).

Automatska konverzija tipa ponekad može uzrokovati neočekivane poruke o grešci kompajlera. Na primjer, kod prikazan ispod, iako izgleda sasvim ispravno, rezultira porukom o grešci tokom faze prevođenja. 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 tip rezultata int, dobijamo poruku o grešci od prevodioca - na kraju krajeva, 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 od 100.

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

Ako izraz sadrži operande float type, tada se tip cijelog izraza automatski promoviše u float. Ako je barem jedan od operanada tipa double, tada se tip cijelog izraza unapređuje u double. Java podrazumevano tretira sve literale sa pomičnim zarezom 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';
šorc = 1024;
int i = 50000;
float f = 5,67f;
udvostručeno=.1234;
dvostruki rezultat = (f*b) + (i/ c) - (d* s);
Sistem, napolje. println ((f* b)+ "+ "+ (i / c)+ "-" + (d* s));
Sistem, napolje. println("rezultat = "+rezultat); )
}

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

Sada kada smo vidjeli sve jednostavne tipove, uključujući cijele brojeve, realne, simbole i logičke vrijednosti, pokušajmo da spojimo sve informacije. Primjer ispod kreira varijable za svaku od njih jednostavni tipovi i prikazuju se vrijednosti ovih varijabli.

klasa SimpleTypes(
public static void main(String args) (
bajt b = 0x55;
kratki s = 0x55ff;
int i = 1000000;
dugo l = 0xffffffffL;
char with= 'a';
float f= .25f;
duplo d = .00001234;
boolean bool = istina;
System.out.println("bajt b = " + b);
System.out.println("short s = " +s);
System.out.println("int i =" + i);
System.out.println("long 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 ispod:

bajt b = 85
šorc = 22015
int i = 1000000
dugo 1 = 4294967295
char with= a
float f = 0,25
duplo 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 sa jakom tipizacijom, što znači da svaki izraz i svaka varijabla ima jako tipiziran određeni tip već u vrijeme kompilacije.
Vrste gipsa
Java nudi sedam tipova cast:

• identitet;


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


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


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


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


• Pretvori u string (String);


• Zabranjene konverzije (zabranjene);

Razmotrimo ih odvojeno.
Transformacija identiteta
Najjednostavnija je transformacija identiteta. U Javi, pretvaranje izraza bilo kojeg tipa u potpuno isti tip je uvijek legalno i uspješno.
Ovo je važno kako bismo teoretski mogli tvrditi da bilo koji tip u Javi može učestvovati u konverziji, čak i ako je identičan.
Primitivna konverzija tipa (proširenje i sužavanje)
Za jednostavne tipove, proširenje znači da se vrši prijelaz sa manje prostranog tipa na veći. Na primjer, od tipa bajt (dužina 1 bajt) do tipa int (dužina 4 bajta). Takve transformacije su sigurne u tom smislu novi tip uvijek je zagarantovano da sadrži sve podatke koji su pohranjeni u starom tipu, te stoga nema gubitka podataka. Zato ga kompajler sam implementira, 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, duplo


• plutati da se udvostruči

Imajte na umu da ne možete pretvoriti u char iz tipova manje od ili jednake dužine(bajt, kratko) ili obrnuto na kratko od char bez gubitka podataka. To je zbog činjenice da je char, za razliku od drugih tipova cijelih brojeva, potpisan.
Međutim, treba imati na umu da čak i uz proširenje, podaci i dalje mogu biti iskrivljeni. To su prebacivanja iz int vrijednosti u float i prebacivanja sa dugih vrijednosti na float ili double. Iako ovi frakcioni tipovi mogu prihvatiti mnogo toga veliki brojevi od odgovarajućih cijelih brojeva, ali imaju manje značajnih znamenki.
Na primjer:

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

Obratite pažnju - sužavanje - znači da se prijelaz vrši s većeg tipa na manje prostran. S takvom konverzijom postoji rizik od gubitka podataka. Na primjer, ako je int bio veći od 127, onda kada se prevede u bajt, bit će izgubljene vrijednosti starije od osme. U Javi se takva konverzija mora izvršiti eksplicitno, tj. 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 izvode se zaokruživanje ili druge radnje da bi se dobio tač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 efekta tokom sužavanja, jer je jednostavno odbačen - ispostavilo se da je rezultat bacanja recipročnih brojeva (384, -384) isti. Posljedično, može se izgubiti ne samo tačna apsolutna vrijednost, već i predznak količine.
Ovo važi i za char:

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

rezultat:

-25536
Konverzija tipa reference (proširenje i sužavanje)
Konverzija tipa objekta je najbolje ilustrovana korištenjem stabla nasljeđivanja. Razmotrimo mali primjer nasljeđivanja:

classParent(
intx;
}

klasa ChildY proširuje roditelja (
int y;
}

klasa ChildZ proširuje Parent(
intz;
}

Svaka klasa deklariše polje sa 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 kompajler, kada provjerava ispravnost p.y izraza, ne može predvidjeti da će referenca p pokazivati ​​na objekt tipa ChildY u vremenu izvođenja. Analizira samo tip same varijable i deklarisana je kao Parent, ali ova klasa nema polje y, što će uzrokovati grešku u kompilaciji.
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 osnovu takvog stabla nasljeđivanja.
Proširenje znači prelazak sa specifičnijeg tipa na manje specifičan tip, tj. prelazak sa djece na roditelje. Kao u slučaju sa primitivni tipovi, ovu tranziciju vrši sam JVM ako je potrebno i "nevidljiv" je programeru, odnosno ne zahtijeva nikakve posebne transformacije.

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

U oba reda, varijablama tipa Parent dodijeljena je vrijednost drugog tipa, š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 dešava samom objektu. Uprkos č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. Promijenjen je samo tip veze preko koje se pristupa objektu.
Obrnuta tranzicija, odnosno spuštanje niz stablo nasljeđivanja do nasljednika, je sužavanje. Na primjer, u ovom slučaju, prijelaz sa reference tipa Parent, koja se može odnositi na objekte tri klase, na referencu tipa ChildY, koja se može odnositi samo na jednu od tri klase, očigledno je sužavanje. Takav prijelaz možda neće biti moguć. Ako se referenca tipa Parent odnosi na objekat tipa Parent ili ChildZ, tada je prijelaz na ChildY nemoguć, jer u oba slučaja objekt nema polje y, koje je deklarirano u ChildY klasi. Stoga, prilikom sužavanja, programer treba eksplicitno naznačiti da je potrebno pokušati izvršiti takvu transformaciju. JVM će provjeriti ispravnost tranzicije u vrijeme izvođenja. Ako je to moguće, konverzija će se izvršiti. Ako nije, pojavit će se greška (obično ClassCastException).

Roditelj p=newChildY();
ChildYcy = (ChildY)p; //desno
Roditelj p2=newChildZ();
ChildYcy2 = (ChildY)p2; //greška

Da biste provjerili da li je ž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;
}

AT ovaj primjer neće doći do grešaka. Prva transformacija je moguća i biće izvršena. U drugom i trećem slučaju, uslovi if naredbi neće raditi i, prema tome, neće biti pogrešnog prijelaza.
Pretvori u niz
Bilo koji tip se može prebaciti na string, tj. na instancu class String. Takva konverzija je izuzetna zbog činjenice da pokriva apsolutno sve vrste.
Različiti tipovi se pretvaraju u niz na sljedeći način:

• Numerički tipovi su upisani tekstualni oblik bez gubitka tačnosti reprezentacije. Prvo, na osnovu primitivne vrijednosti, generira se instanca odgovarajuće klase “wrapper”, a zatim se na njoj poziva metoda toString(). Ali pošto su ove radnje nevidljive izvana, JVM ih optimizuje i pretvara primitivne vrijednosti direktno slati tekst.


• Booleove vrijednosti se prebacuju na 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 dozvoljeni svi prijelazi između proizvoljnih tipova. Na primjer, zabranjene konverzije uključuju: prijelaze sa bilo kojeg referentnog tipa na primitivni i obrnuto (osim konverzije u string), boolean se može prebaciti samo na ovaj tip ili na string. 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 ilustruje referentne tipove, prijelaz iz ChildY u ChildZ je zabranjen.
Ova lista zabranjenih transformacija nije iscrpljena. Prilično je širok, a istovremeno su sve opcije prilično očigledne, tako da ih nećemo detaljno razmatrati. Oni koji žele mogu dobiti pune informacije iz specifikacije.
Naravno, pokušaj izvršenja zabranjene konverzije će uzrokovati grešku.

Korištenje gipsa
Situacije konverzije tipa mogu se grupirati na sljedeći način:

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


• Poziv metode. Ova konverzija se primjenjuje na argumente pozvane metode ili konstruktora. Takvo prebacivanje nikada ne stvara greške. Casting se također vrši prilikom vraćanja vrijednosti metode.


• Eksplicitna glumačka ekipa. U ovom slučaju, eksplicitno je navedeno na koji tip želite da prevedete originalnu vrijednost.


• Operator konkatenacije pretvara u niz svojih argumenata.


• Numerička ekspanzija. Numeričke operacije može zahtijevati promjenu tipa argumenata. Ova transformacija ima poseban naziv - proširena, od izbora tip cilja može zavisiti ne samo od početne vrijednosti, već i od drugog argumenta operacije.

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

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

Primjer 1: Dodjela vrijednosti varijabli jednog tipa drugoj

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

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

1. Automatska konverzija

Razmotrite prvu automatsku konverziju. Ako su oba tipa kompatibilna, 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 konverziju tipa moraju biti ispunjena dva uslova:

• oba tipa moraju biti kompatibilna
• dužina tipa cilja mora biti veća od dužine početni tip

U ovom slučaju, to se dešava ekspanzijska konverzija.

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

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

Na primjer, tip podataka int uvijek dovoljno velik da sve primi dozvoljene vrijednosti tip bajt , tako da nema eksplicitnih operatora cast ovaj slučaj nije potrebno. U smislu konverzije proširenja, numerički tipovi podataka, uključujući cijeli broj i pokretni zarez, međusobno su kompatibilni. Istovremeno, nema automatske konverzije numeričkih tipova u tip char ili boolean . Vrste char i boolean takođe međusobno nekompatibilni.

Vrijedi malo objasniti zašto, na primjer, tip bajt se ne pretvara automatski (implicitno) u tip char , iako tip bajt je širok 8 bita, i char - 16, isto važi i za konverziju tipa kratko in char . Ovo se dešava zato što bajt i kratko potpisani tipovi podataka, i char nepotpisan. Stoga, u ovom slučaju, morate koristiti eksplicitno uvođenje tipova, budući da kompajler mora eksplicitno naznačiti da znate šta želite i kako će se bit znakova tipova obraditi bajt i kratko prilikom pretvaranja u tip char .

Tip Value Behavior char u većini slučajeva poklapa se s ponašanjem vrijednosti cjelobrojnog tipa, dakle vrijednost tipa char može se koristiti gdje god su potrebne vrijednosti int ili dugo . Međutim, podsjećamo da je tip char je bez predznaka, pa se ponaša drugačije od tipa kratko , iako je raspon oba tipa 16 bita.

2. Casting

Uprkos svim pogodnostima automatske konverzije tipa, ona nije u stanju da zadovolji sve hitne potrebe. Na primjer, šta ako vrijednost tipa int mora biti dodijeljen varijabli tipa bajt ? Ova konverzija se neće izvršiti automatski zbog dužine tipa bajt manje od tipa int . Ponekad se ova vrsta transformacije naziva sužavanje transformacije, budući da je vrijednost jasno sužena kako bi se uklopila u ciljni tip podataka.

Da biste pretvorili dva nekompatibilna tipa podataka, trebate koristiti cast. Cast je samo eksplicitna konverzija tipa. Opšti oblik odlijevanje tipa ima sljedeći oblik:

(target_type) vrijednost

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

Primjer 2: Casting

Na primjer, u sljedećem isječku koda otkucajte 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 se jednostavno 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 prebacivanja većeg cjelobrojnog tipa na manje obimniji 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 plutajućim u manji cijeli broj

Prilikom prebacivanja 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 konverzije tipova se također mogu izvesti u izrazima.

AT Java jezik važe sljedeća pravila:

1. Ako je jedan operand tipa duplo duplo.
2. float, drugi se također pretvara u tip float.
3. Inače, ako je jedan operand tipa dugo, drugi se također pretvara u tip dugo.
4. Inače, oba operanda se konvertuju u tip int.
5. Kombinovane izraze dodjeljivanja (+=,-=,*=,/=) nije potrebno baciti.

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 grešku kompilacije. Ali kada se koristi kombinovani 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

AT sljedeći primjer doći će i do greške u kompilaciji - uprkos činjenici da brojevi poput bajt, rezultat operacije će biti tip int, ali ne kratko.

Javna klasa IntegerDemo1 (javni statički void main(String args) (bajt b1 = 50, b2 = -99; kratko k = b1 + b2; //greš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 prebacivanje 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. Šta je eksplicitno i automatsko livenje vrste u izrazima?

Prebacivanje tipa može biti eksplicitno ili automatsko.

Kod eksplicitnog ulijevanja tipa, sama operacija lijevanja je eksplicitno specificirana.

Za automatsko livenje potrebno je da budu ispunjena dva uslova:

• oba tipa moraju biti kompatibilna;
• dužina tipa izvora (izvornog tipa) mora biti manja od dužine tipa cilja (tipa odredišta).

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

Eksplicitno uvođenje tipova omogućava dodjelu nekompatibilnih tipova. Opći oblik eksplicitnog uvođenja tipova je:

(target_type) vrijednost

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

Primjeri eksplicitna konverzija tipa.

// eksplicitno uvođenje tipova u izraze bajt b; int a; duplo d; float 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 livenja

Primjer 1. Automatsko livenje integralnih tipova.

// automatsko livenje integralnih tipova int a; bajt b; short sh; b = -23; a = b; // a = -23 - automatsko lijevanje tipa sh = -150; a = sh; // a = -150 dužina l = 200; // Greška: "Nepodudaranje tipa: 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 - kod znakova "Z" boolean b1 = lažno; //a = b1; - greška, tipovi su nekompatibilni

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

// automatsko prebacivanje u pokretni zarez float f; duplo d; f = 3,409033f; d = f; // d = 3,409033

Primjer 3. Automatsko livenje mješoviti tipovi. Takav slučaj je moguć ako se varijabli tipa floating point dodijeli vrijednost varijable cjelobrojnog tipa.

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

4. Kako se vrši automatska promocija tipa u izrazima?

Automatska promocija tipovi se javljaju u izrazima. U ovom slučaju, vrijednost koja se pojavljuje u izrazima automatski se promovira u tipove s velikim rasponima vrijednosti.

Kada automatski promovirate tipove u izrazima:

• ako je jedan od cjelobrojnih operanda tipa int, tada se sve vrijednosti byte, short i char promovišu 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 sa 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 bajta. 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 napišeš ovako:

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

tada će doći do greške pri kompilaciji 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 kompajler će izdati poruku o grešci.

Ako uradite eksplicitno prebacivanje tipa:

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

onda se u ovom slučaju rezultat 5000 tipa int pretvara u bajt tipa. Kao što znate, varijabla int uzima 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 se odnose na varijable tipa kratki i char.

6. Primjer. Promocija od tipa byte do tipa int, u kojem izraz sadrži varijabilni operand tipa int

// promocija tipova u izrazima // bajt -> int bajt b; int d; d=20; // greška, rezultat je tipa int, pošto je varijabla d tipa int // b = 1000 / d;

U gornjem primjeru, izraz koristi varijablu d tipa int. Stoga će kompajler dati poruku o grešci:

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

To znači da je rezultat tipa int (ne byte) čak i ako se vrijednost uklapa u raspon vrijednosti bajta. Pošto izraz koristi promenljivi operand d tip int.

Ako implementirate eksplicitnu konverziju tipa, onda će rezultat biti ispravan:

// promocija 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; // greš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.