Ukucajte konverziju u java. Automatska konverzija tipova u izrazima

Ovaj članak:

• napisao tim. Nadamo se da će vam biti od koristi. Sretno čitanje!
• ovo je jedan od naših članaka

Konverzija tipova je tema koja može izgledati zastrašujuće za one koji su novi u Java programiranju. Međutim, uvjeravamo vas da je sve zapravo jednostavno. Glavna stvar je razumjeti koji zakoni upravljaju interakcijom između varijabli i zapamtite to kada pišete programe. Pa, hajde da shvatimo.

Postoje 2 vrste transformacija u Javi - slika će vam pomoći:

Podsjetimo da se cijeli “Java univerzum” sastoji od:

• primitivni tipovi(byte, short, int, long, char, float, double, boolean)
• objekata

U ovom članku mi:

• razmotrite konverziju tipova za primitivne tipove varijabli
• konverzija objekata (String, Scanner, itd.) se ne razmatra u ovom članku, budući da se objektima događa posebna „magija“ - ovo je tema za poseban članak.

Automatska konverzija

Pa, hajde da pokušamo da shvatimo šta je "automatska konverzija".

Zapamtite, kada smo gledali tipove varijabli (u članku), rekli smo to varijabla je neka vrsta "kontejnera" , koji može pohraniti vrijednost za kasniju upotrebu u programu. Također smo razgovarali o tome da svaki tip varijable ima svoj raspon prihvatljive vrijednosti i količinu zauzete memorije. Evo znaka gdje je sve to ispisano:

Dakle, ovo je ono na šta zapravo idemo. Osim toga, ne radi se samo o tome da ste dobili opsege prihvatljivih vrijednosti i količinu zauzete memorije :)

Uporedimo, na primjer:

1. bajt i kratki. bajt ima manji raspon važećih vrijednosti od kratkog. To jest, bajt je kao manji okvir, a kratki je veći okvir. A to znači možemo staviti bajt u kratko.

2. bajt i int. bajt ima manji raspon važećih vrijednosti od int. To jest, bajt je kao manji okvir, a int je kao veći okvir. A to znači možemo staviti bajt u int.

3. int i long. int ima manji raspon važećih vrijednosti od long. To jest, int je kao manja kutija, a long je kao veća kutija. A to znači možemo staviti int u long.

Ovo je primjer automatske konverzije. Ovo se može shematski prikazati u obliku slike ovako:

Pogledajmo kako to funkcionira u praksi.

Primjer br. 1

Kod br. 1 - ako pokrenete ovaj kod na svom računaru,

klasa Test (javni statički void main(String args) (bajt a = 15; bajt b = a; System.out.println(b); ) )

razredni test ( bajt a = 15; bajt b = a;

Kod br. 2 - ako pokrenete ovaj kod na svom računaru, broj 15 će biti prikazan na konzoli

klasa Test (javni statički void main(String args) (bajt a = 15; int b = a; System.out.println(b); ) )

razredni test ( public static void main (String args) ( bajt a = 15; int b = a; Sistem. out . println(b);

Eeyore? Da li mislite tako puta je isti broj izbačen na konzolu, i kod br. 1 razlikuje se od koda br. 2 samo po tipu varijable b , onda nema razlike između njih? E to nije istina.

Kod br. 2 sadrži automatskikonverzija tipa , ali u kodu br. 1 - ne:

Iako je broj u principu isti, sada je u b O veći kontejner koji zauzima više prostora na disku. U ovom slučaju, JVM izvodi automatske konverzije umjesto vas. Ona to zna int više nego bajt .

Cast

Druga je stvar ako pokušavate prenijeti nešto iz većeg kontejnera u manji.

Možda znate da veći kontejner sadrži nešto što može stati u mali - ali JVM ne zna za to i pokušava vas zaštititi od grešaka.

Stoga, morate "jednostavno reći" da je situacija pod kontrolom:

klasa Test (javni statički void main(String args) (int a=0; long b=15; a = (int) b; ))

razredni test ( public static void main (String args) ( int a = 0; dugo b = 15; a = (int) b;

Ovdje smo dodali (int) prije b. Ako je varijabla a bilo je, na primjer, kao bajt, u zagradama bi bilo (bajt) . Opća formula izgleda ovako:

Ona kaže „imajte (više) značenja b varijabla tipa koji mi treba (cilj) int ".

Ako je nešto pošlo po zlu.

Prije toga, pristupali smo situacijama pod pretpostavkom da tačno znamo šta radimo. Ali šta ako pokušate da stavite nešto u posudu što tu ne stane?

Ispostavilo se da će u kontejneru ostati samo ono što tamo „stane“. Na primjer, brojevi s pomičnim zarezom će biti "odsječeni" frakcija:

//primjer 1 klase Test (javni statički void main(String args) (dvostruki a=11.2345; int b=(int)a; System.out.println(b); // konzola će prikazati broj 11))

//primjer 1 razredni test ( public static void main (String args) ( duplo a = 11,2345 ; int b = (int) a; Sistem. out . println(b); // konzola će prikazati broj 11

Moramo zapamtiti da je razlomak nije zaobljen, A odbačen.

Šta se događa ako pokušamo postaviti broj koji je izvan dozvoljenog raspona? Na primjer, ako stavite broj 128 u bajt (opseg bajtova od -128 do 127)? Mislite li da ćemo dobiti 1? br. Dobijamo -128:

class Test ( public static void main(String args) (dvostruki a=128; bajt b=(byte)a; System.out.println(b); //vidjet ćemo -128 u konzoli))

Vrijednost varijable sa takvom transformacijom može se izračunati, ali cilj programera je izbjeći situaciju da vrijednost prelazi dozvoljene granice, jer to može dovesti do kvar programe.

Zadaci:

1. Dosljedno pišite u kompajler konverzije svih primitivnih tipova jedne u druge, uključujući char i tipove. Napravite tabelu poput ove:

	bajt	kratko	char	int	dugo	float	duplo	boolean
bajt
kratko
char
int
Dugo
Float
duplo
boolean

Na raskrsnici napišite: a - ako se konverzija dogodi automatski, on - ako trebate koristiti eksplicitnu konverziju, x - ako je konverzija nemoguća.

* pozivanje tipa na sebe identičan– nije potrebno registrovati

1. Pogledajte još jednom koja je veličina svakog primitivnog tipa. Pokušajte napraviti dijagram toka koji pokazuje koje vrste gdje idu. Nacrtajte strelice označene kao "proširujuća transformacija" i "sužavajuća transformacija".

Pitanja

Tokom intervjua za poziciju Junior Java Developer, možda ćete biti upitani:

Šta znate o pretvaranju primitivnih tipova podataka, postoji li gubitak podataka, da li je moguće pretvoriti boolean tip?

Pokušajte odgovoriti na pitanje.

Hajde da rezimiramo:

• Ako sadržaj manjeg spremnika "stavite" u veći spremnik, konverzija se događa automatski i ne bi trebalo doći do grešaka.

• Ako postoji potreba da stavite “vrijednost iz većeg spremnika u manji”, morate biti oprezni i koristiti eksplicitno uvođenje tipa.

• Prilikom prebacivanja tipova float ili double u integer tipove, razlomak se ne zaokružuje, već se jednostavno odbacuje.
• Tip boolean nije kababilan ni na jedan tip.
• Tip char se pretvara u numeričke tipove, kao kod znakova u UNICODE sistemu.
• Ako je broj veći od njegovog spremnika, rezultat će biti nepredvidiv.

Ovaj članak opisuje samo dio materijala na temu lijevanja tipa. Tu su i prelivanja tipa objekata, prebacivanja na string (na kraju krajeva, sve se može napisati u string, zar ne?) i automatska promocija tipa u izrazima.

Nadamo se da vam je naš članak bio koristan. Postoji i mogućnost da se upišete na naše Java kurseve u Kijevu. Učimo od nule. Detaljne informacije Možete ga pronaći na našoj web stranici.

Završili smo naš zadnji članak o tome šta sam obećao da ću vam reći, koje vrste se mogu dati i kako se to sve radi. Hajde da počnemo.

Cast u aritmetičkim izrazima se izvodi automatski.

byte->short->int->long->float->double

Ako su operandi a i b kombinovani binarnim operatorom (o tome ćemo raspravljati u nastavku), pre njegovog izvršenja, oba operanda se konvertuju u isti tip podataka na sledeći način:

• Ako je jedan od operatora tipa double, drugi se također pretvara u double;
• Ako je jedan od operatora tipa float, drugi se također pretvara u float;
• Ako je jedan od operatora tipa long, drugi se također pretvara u long;
• Ako je jedan od operatora tipa int, drugi se takođe konvertuje u int;

Dozvoljene konverzije tipova

Pune linije prikazuju transformaciju izvedenu bez gubitka informacija. Ova konverzija se vrši implicitno. Transformacije u kojima može doći do gubitka informacija nazivaju se kastingom. Prikazane su isprekidanim linijama. Ako na slici nema linija za tip podataka, onda takva konverzija nije moguća. Transformacije sa gubitkom informacija moraju se provoditi vrlo pažljivo. Dakle, možete izgubiti značajan dio podataka, a program i dalje može raditi ispravno.

Da bi se suzile kaste, to treba eksplicitno učiniti. Na primjer: bajt b = (bajt)128; cast int na tip bajta.

Predlažem da napravite nekoliko primjera.

Možda ste malo pogrešno shvatili ovaj kod pošto još nisam objasnio šta su kompajler, konstante itd. Kasnije na treningu ću vam sve reći, iako sam to trebao učiniti ranije. A sada želim da opišem koja pravila treba da imaju imena varijabli.

• Imena varijabli ne mogu početi brojem; ne mogu koristiti aritmetiku ili simbole u svojim imenima. logički operatori, kao i simbol '#'.
• Upotreba znakova '$' ili '_' je prihvatljiva, uključujući prvu poziciju i ime.
• Varijabla primitivnog tipa deklarirana kao član klase (globalna varijabla) je po defaultu postavljena na nulu.
• Ako je varijabla deklarirana kao lokalna varijabla u metodi, mora biti inicijalizirana prije upotrebe. Zato što lokalne varijable nisu inicijalizirane po defaultu. To znači da ne možete deklarirati lokalnu varijablu i ostaviti je neinicijaliziranom. Odnosno, ovako: int i;. Ako to učinite u metodi, kompajler će od vas tražiti da postavite zadanu vrijednost, dok će pri kreiranju takve varijable kao člana klase (globalno), sam prevodilac postaviti na 0.
• Opseg i životni vijek varijable ograničeni su blokom () u kojem je deklarirana. Ako ste kreirali varijablu unutar metode (kao što smo učinili u primjerima), onda je ne možete koristiti izvan metode, jer je metoda ograničena zagradama (). Globalna varijabla je vidljiva u svim blokovima.
• Također je zabranjeno korištenje rezervirano java words. Cijela lista ključne riječi možete vidjeti na slici ispod.

A pošto sam se u ovom članku dotaknuo izraza binarnog operatora, predlažem da razmotrimo operatore u Javi. Štaviše, nema mnogo teorije.

Java ima nekoliko tipova operatora: jednostavnu dodelu, aritmetičke, unarne, jednake i relacione, uslovne, poređenje tipova, bitove i pomeranje bitova.

Ima puno pametnih riječi, ali ova slika sve objašnjava vrlo jednostavno:

Prvo ćemo koristiti operatore poređenja po bitu, dodjelu i postfiks. Ostali operatori nisu tako česti, pa ćemo razmotriti samo one koje ćemo koristiti.

javna klasa OperatorsInJava (

int a = 5;

int b = 6;

int suma = a + b;

int razlika = a - b;

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.

Prilikom izvođenja automatskog livenja moraju biti ispunjena dva uslova:

• oba tipa moraju biti kompatibilna;
• dužina originalni tip(tip izvora) mora biti manji od dužine tip cilja(tip prijemnika).

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

Eksplicitno uvođenje tipova omogućava dodjelu nekompatibilnih tipova. Opšti oblik Eksplicitno prebacivanje tipa izgleda ovako:

(target_type) vrijednost

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

Primjeri eksplicitno uvođenje 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ćuje vrijednost a = -27; b = (bajt)a; // b = -27

3. Primjeri automatskog livenja

Primjer 1. Automatsko livenje cjelobrojnih tipova.

// automatsko uvođenje cjelobrojnih 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 bacanje tipova s ​​pomičnim zarezom float f; duplo d; f = 3,409033f; d = f; // d = 3,409033

Primjer 3. Automatsko livenje mješoviti tipovi. Ovaj slučaj je moguć ako varijabilni tip pomičnom zarezu se dodjeljuje vrijednost varijable cjelobrojnog tipa.

// automatsko livenje 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?

Automatsko unapređenje tipa se dešava u izrazima. U ovom slučaju, vrijednosti koje se pojavljuju u izrazima automatski se promoviraju u tipove s velikim rasponima vrijednosti.

Kada automatski promovirate tipove u izrazima:

• ako je jedan od cjelobrojnih operanda tipa int, tada se sve vrijednosti tipa byte, short i char promoviraju u tip int;
• ako je jedan od cjelobrojnih operanda tipa long, tada se cijeli izraz promoviše u tip long;
• ako se jedan od operanada odnosi na float type, tada će tip cijelog izraza također biti tipa float (ako ne postoje operandi tipa double);
• ako je jedan od operanada tipa double, tada će i tip cijelog izraza biti double.

5. Primjer unapređenja od bajta do tipa int u kojem izraz ne sadrži promjenjive operande tip int(dugo)

// bajt -> int bajt b; b = 1000 / 20; // b = 50, radi jer je rezultat postavljen u bajt tip

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 u bajt i može ispravno stati u varijablu b .

Ako to napišete ovako:

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

tada će se pojaviti greška kompilacije sa porukom:

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

100000 / 20 = 5000

Tada ovaj broj (5000) automatski postaje int tip i kompajler će generisati poruku o grešci.

Ako radite 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 tipa int zauzima 32 bita, a varijabla tipa byte zauzima 8 bita. Vrijednost int varijable je skraćena. I imamo ono što imamo (b = -120).

Gornji primjeri se također primjenjuju na varijable tipa short i char.

6. Primjer. Promocija od bajta do int gdje izraz sadrži int varijabilni operand

// promoviranje 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 tip int. Stoga će kompajler proizvesti poruku o grešci:

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

To znači da je rezultat int (a ne bajt) čak i ako se vrijednost uklapa u raspon vrijednosti bajta. Zato što izraz koristi varijablu operanda d tip int.

Ako izvršite eksplicitno prebacivanje tipa, rezultat će biti ispravan:

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

7. Primjer. Promocija sa int na dugo

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 dugog tipa l = 100; // greška, jedan od operanada je tipa long // d = l * 2;

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

Ponekad se pojave situacije kada imate neku vrijednost određeni tip, ali morate ga dodijeliti varijabli drugog tipa. Za neke tipove to se može učiniti bez uvođenja tipova; u takvim slučajevima govore o automatskoj konverziji tipa. U Javi, automatska konverzija je moguća samo ako je numerički prikaz odredišne ​​varijable dovoljno precizan da pohrani originalnu vrijednost. Takva konverzija se događa, na primjer, kada se unese literalna konstanta ili vrijednost varijable tipa byte ili short u varijablu tipa int. To se zove proširenje (proširenje) ili povećati (promocija), jer je tip nižeg bita proširen (promoviran) u veći kompatibilni tip. Veličina tipa int je uvijek dovoljna za pohranjivanje brojeva iz raspona dozvoljenog tipom bajta, dakle in slične situacije Eksplicitni operator cast tipa nije potreban. Obrnuto nije tačno u većini slučajeva, pa da biste dodelili vrednost tipa int promenljivoj tipa bajt, morate koristiti operator cast tipa. Ova procedura se ponekad naziva sužavanje (sužavanje), jer izričito govorite prevodiocu da vrijednost treba konvertirati da bi se uklopila u varijablu željenog tipa. Da biste prebacili vrijednost na određeni tip, prethodite joj navođenjem tog tipa, zatvorenog u zagradama. Sljedeći isječak koda pokazuje pretvaranje tipa izvora (int varijable) u tip odredišta (bajt varijabla). Ako bi, tokom takve operacije, vrijednost cijelog broja bila izvan raspona dozvoljenog za tip bajta, ona bi se smanjila modulo dijeljenjem rasponom dozvoljenim za bajt (rezultat modulo dijeljenja brojem je ostatak dijeljenja sa taj broj),

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

2.2.1. Automatska konverzija tipova u izrazima

Prilikom izračunavanja 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 biti izvan raspona vrijednosti dozvoljenih za tip bajta. To je razlog zašto Java automatski promoviše tip svakog dijela izraza u tip int, tako da ima dovoljno mjesta za srednji rezultat (a* b).

Automatska konverzija tipa ponekad može uzrokovati neočekivane poruke o grešci prevodioca. 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 automatske konverzije tipa rezultata u int, primamo poruku o grešci od prevoditelja - na kraju krajeva, prilikom pisanja 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 inbajt)

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

što uzrokuje da se b postavi na ispravnu vrijednost 100.

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

Ako izraz sadrži operande tipa float, tada se tip cijelog izraza automatski promoviše u float. Ako je barem jedan od operanada tipa double, tada se tip cijelog izraza podiže na 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) (
bajt b= 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 bajtom, tako da se njegov tip automatski unapređuje u float. Tip sljedećeg podizraza i/c (int podijeljen sa char) se unapređuje u int. Slično, tip podizraza d*s (dvostruko kratko) se unapređuje u dvostruko. U sljedećem koraku proračuna bavimo se tri međurezultata tipova float, int i double. Prvo, kada se dodaju prva dva, tip int se unapređuje u float i rezultat je float. 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 brojeve, znakove i logičke vrijednosti, pokušajmo to sve spojiti. 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=” + s);
System.out.println("float f = " + f);
System.out.println("double d = " + d);
System.out.println("boolean bool =" + bool); )
}

Pokretanjem ovog programa trebalo bi da dobijete izlaz 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 boolean = istina

Imajte na umu da se cijeli brojevi ispisuju u decimalnom zapisu, iako smo vrijednosti nekih od njih naveli u heksadecimalnom zapisu.

Posljednje ažuriranje: 29.10.2018

Svaki osnovni tip podaci zauzimaju određeni broj bajtova memorije. Ovo postavlja ograničenja na operacije koje uključuju Razne vrste podaci. Razmotrite sljedeći primjer:

Int a = 4; bajt b = a; // ! Greška

U ovom kodu ćemo naići na grešku. Iako i tip bajta i tip int predstavljaju cijele brojeve. Štaviše, vrijednost varijable a, koja je dodijeljena varijabli tipa bajt, dobro je unutar raspona vrijednosti za tip bajt (od -128 do 127). Međutim, nailazimo na grešku u fazi kompilacije. Od u u ovom slučaju pokušavamo dodijeliti neke podatke koji zauzimaju 4 bajta varijabli koja će uzeti samo jedan bajt.

Međutim, program može zahtijevati da se izvrši takva konverzija. U ovom slučaju, moram koristiti operaciju konverzije tipa (() operacija):

Int a = 4; bajt b = (bajt)a; // konverzija tipa: iz tipa int u tip bajta System.out.println(b); // 4

Operacija konverzije tipa uključuje navođenje u zagradama tipa u koji se vrijednost mora pretvoriti. Na primjer, u slučaju operacije (byte)a, podaci tipa int se pretvaraju u tip bajta. Kao rezultat, dobićemo vrijednost tipa byte.

Eksplicitne i implicitne konverzije

Kada jedna operacija uključuje podatke različite vrste, nije uvijek potrebno koristiti operaciju konverzije tipa. Neke vrste transformacija se izvode implicitno, automatski.

Automatske konverzije

Strelice na slici pokazuju koje se konverzije tipa mogu izvršiti automatski. Isprekidane strelice pokazuju automatske konverzije sa gubitkom preciznosti.

Automatski proizveden bez ikakvih problema proširene transformacije(proširivanje) - proširuju reprezentaciju objekta u memoriji. Na primjer:

Bajt b = 7; int d = b; // konverzija iz bajta u int

U ovom slučaju, vrijednost tipa byte, koja zauzima 1 bajt u memoriji, proširuje se na tip int, koji zauzima 4 bajta.

Proširene automatske transformacije predstavljene su sljedećim lancima:

bajt -> kratko -> int -> dugo

int -> duplo

kratko -> plutajući -> duplo

char -> int

Automatske konverzije sa gubitkom preciznosti

Neke konverzije se mogu izvršiti automatski između tipova podataka iste širine bita, ili čak iz tipa podataka sa većom širinom bita u tip sa manjom širinom bita. To su sljedeći lanci konverzija: int -> float, long -> float i long -> double se izvode bez grešaka, ali tokom konverzije možemo naići na gubitak informacija.

Na primjer:

Int a = 2147483647; float b = a; // od int do float System.out.println(b); // 2.14748365E9

Eksplicitne konverzije

Sve druge konverzije primitivnih tipova eksplicitno primjenjuju operaciju konverzije tipa. Obično su to sužavanje konverzija od tipa sa većom širinom bita u tip sa manjom širinom bita:

Dugačak a = 4; int b = (int) a;

Gubitak podataka tokom konverzije

Kada koristimo eksplicitne konverzije, možemo naići na gubitak podataka. Na primjer, nećemo imati problema sa sljedećim kodom:

Int a = 5; bajt b = (bajt) a; System.out.println(b); // 5

Broj 5 se dobro uklapa u raspon vrijednosti bajtova, tako da će nakon konverzije varijabla b biti jednaka 5. Ali šta se događa u sljedećem slučaju:

Int a = 258; bajt b = (bajt) a; System.out.println(b); // 2

Rezultat će biti broj 2. U ovom slučaju, broj 258 je izvan opsega za tip bajta (od -128 do 127), tako da će vrijednost biti skraćena. Zašto će rezultat biti broj 2?

Broj a, koji je 258, in binarni sistem biće jednako 00000000 00000000 00000001 00000010 . Vrijednosti bajtova zauzimaju samo 8 bita memorije. Zbog toga binarno predstavljanje int broj je skraćen na desno 8 cifara, odnosno 00000010 , što u decimalni sistem daje broj 2.

Skraćivanje racionalnih brojeva na cijele brojeve

Prilikom pretvaranja vrijednosti s pomičnim zarezom u cjelobrojne vrijednosti, razlomljeni dio se skraćuje:

Dvostruko a = 56,9898; int b = (int)a;

Ovdje bi vrijednost b bila 56, iako bi 57 bilo bliže 56,9898. Da biste izbjegli takve incidente, trebate koristiti funkciju zaokruživanja koja je dostupna u matematička biblioteka Java:

Dvostruko a = 56,9898; int b = (int)Math.round(a);

Transformacije tokom operacija

Često postoje situacije kada je potrebno koristiti različite operacije, na primjer, zbrajanje i proizvod, na vrijednostima različitih tipova. I ovdje vrijede neka pravila:

ako je jedan od operanada operacije tipa double, onda se drugi operand pretvara u tip double

ako prethodni uslov nije ispunjen, a jedan od operanada operacije je tipa float, tada se drugi operand pretvara u tip float

ako prethodni uslovi nisu ispunjeni, jedan od operanada operacije je tipa long , tada se drugi operand pretvara u tip long

inače se svi operandi operacije konvertuju u tip int

Primjeri transformacija:

Int a = 3; duplo b = 4,6; duplo c = a+b;

Budući da operacija uključuje dvostruku vrijednost, obje druge vrijednosti se pretvaraju u tip double, a zbir dviju vrijednosti a+b predstavlja dvostruki tip.

Drugi primjer:

Bajt a = 3; kratko b = 4; bajt c = (bajt)(a+b);

Dvije varijable su tipa byte i kratke (ne double, float ili long), tako da se kada se dodaju pretvaraju u tip int, a njihov zbir a+b predstavlja vrijednost int. Stoga, ako zatim dodijelimo ovaj iznos varijabli tipa bajt, onda opet moramo izvršiti konverziju tipa u bajt.

Ako operacije uključuju podatke tipa char, oni se konvertuju u int:

Int d = "a" + 5; System.out.println(d); // 102