Pretvorba tipa u Javi. Automatska pretvorba tipa u izrazima

Ovaj članak:

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

Pretvorba tipa je tema koja se može činiti zastrašujućom za one koji su tek upoznati s Java programiranjem. Međutim, uvjeravamo vas da je sve zapravo jednostavno. Glavno je razumjeti koji zakoni upravljaju interakcijom između varijabli i zapamtite to kada pišete programe. Dakle, idemo shvatiti.

U Javi postoje 2 vrste transformacija - slika će vam pomoći:

Podsjetimo se da se cijeli "Java svemir" sastoji od:

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

U ovom članku mi:

• razmotrite pretvorbu tipa za primitivne tipove varijabli
• pretvorba objekata (String, Scanner, itd.) nije razmatrana u ovom članku, budući da se s objektima događa posebna "magija" - ovo je tema za poseban članak.

Automatska konverzija

Pa, pokušajmo shvatiti što je "automatska pretvorba".

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

Dakle, ovo je ono do čega zapravo dolazimo. Osim toga, nije samo da ste dobili raspone prihvatljivih vrijednosti i količinu zauzete memorije :)

Usporedimo npr.

1. bajt i kratki. byte ima manji raspon važećih vrijednosti nego short. Odnosno, byte je kao manja kutija, a short je veća kutija. A to znači možemo staviti bajt u kratko.

2. bajt i int. byte ima manji raspon valjanih vrijednosti od int. Odnosno, byte je kao manja kutija, a int je kao veća kutija. A to znači možemo staviti bajt u int.

3. int i dugi. int ima manji raspon valjanih vrijednosti nego long. Odnosno, int je kao manja kutija, a long je kao veća kutija. A to znači možemo staviti u dugo.

Ovo je primjer automatske pretvorbe. To se shematski može prikazati u obliku slike poput ove:

Pogledajmo kako to funkcionira u praksi.

Primjer br. 1

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

klasa Test ( public static void main(String args) ( byte a = 15; byte b = a; System.out.println(b); ) )

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

Kod br. 2 - ako pokrenete ovaj kod na svom računalu, na konzoli će se prikazati broj 15

klasa Test ( public static void main(String args) ( byte a = 15; int b = a; System.out.println(b); ) )

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

Eeyore? Misliš li to puta je isti broj izbačen na konzolu, a kod br. 1 razlikuje se od koda br. 2 samo po vrsti varijable b , onda nema razlike među njima? E to nije istina.

Kod broj 2 sadrži automatskipretvorba tipa , ali kod br. 1 - ne:

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

Cast

Druga je stvar ako nešto pokušavate pretočiti iz veće posude u manju.

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

Stoga morate “jasno reći” da je situacija pod kontrolom:

klasa Test ( public static void main(String args) ( int a=0; long b=15; a = (int) b; ) )

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

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

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

Ako je nešto pošlo po zlu.

Prije toga smo situacijama pristupali pretpostavljajući da točno znamo što radimo. Ali što ako pokušate staviti nešto u spremnik što tamo ne stane?

Ispada da će u spremniku ostati samo ono što tamo "stane". Na primjer, brojevi s pomičnim zarezom bit će "odrezani" frakcija:

//primjer 1 klase Test ( public static void main(String args) ( double 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) ( dvostruko a = 11,2345; int b = (int ) a ; Sustav. van . println(b); // konzola će prikazati broj 11

Moramo zapamtiti da je razlomački dio nije zaobljena, A odbačena.

Što se događa ako pokušamo postaviti broj koji je izvan dopuštenog raspona? Na primjer, ako stavite broj 128 u bajt (raspon bajtova od -128 do 127)? Mislite li da ćemo dobiti 1? Ne. Dobivamo -128:

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

Vrijednost varijable s takvom transformacijom može se izračunati, ali cilj programera je izbjeći situaciju u kojoj vrijednost prelazi dopuštene granice, jer to može dovesti do kvar programa.

Zadaci:

1. Dosljedno zapišite u kompajler međusobne konverzije svih primitivnih tipova, uključujući char i tipove. Napravite tablicu poput ove:

	bajt	kratak	char	int	dugo	plutati	dvostruko	Booleov
bajt
kratak
char
int
dugo
Plutati
dvostruko
Booleov

Na raskrižju napišite: a - ako se pretvorba događa automatski, na - ako trebate koristiti eksplicitnu pretvorbu, x - ako je pretvorba nemoguća.

* poziva se pretvaranje tipa u samoga sebe identičan– nije ga potrebno registrirati

1. Ponovno pogledajte koje je veličine svaki primitivni tip. Pokušajte napraviti dijagram toka koji prikazuje koje vrste kamo idu. Nacrtajte strelice s oznakom "transformacija širenja" i "transformacija sužavanja".

Pitanja

Tijekom intervjua za poziciju Junior Java Developer, mogli biste biti upitani:

Što znate o pretvaranju primitivnih tipova podataka, postoji li gubitak podataka, je li moguće pretvoriti Boolean tip?

Pokušajte odgovoriti na pitanje.

Ukratko:

• Ako sadržaj manjeg spremnika "stavite" u veći spremnik, pretvorba se događa automatski i ne bi se smjele pojaviti greške.

• Ako postoji potreba za stavljanjem "vrijednosti iz većeg spremnika u manji", morate biti oprezni i koristiti eksplicitno pretvaranje tipa.

• Prilikom pretvaranja float ili double u cjelobrojne tipove, razlomački dio se ne zaokružuje, već se jednostavno odbacuje.
• Tip boolean ne može se pretvoriti ni u jedan tip.
• Tip char pretvara se u numeričke tipove, poput znakovnog koda u UNICODE sustavu.
• Ako je broj veći od spremnika, rezultat će biti nepredvidiv.

Ovaj članak opisuje samo dio materijala na temu lijevanja tipa. Tu su i pretvaranja tipa objekta, pretvaranja u niz (uostalom, sve se može napisati u nizu, zar ne?) i automatsko unapređenje tipa u izrazima.

Nadamo se da vam je naš članak bio koristan. Također postoji mogućnost upisa na naše Java tečajeve u Kijevu. Podučavamo od nule. Detaljne informacije Možete ga pronaći na našoj web stranici.

Završili smo naš prošli članak o onome što sam vam obećao reći, koje se vrste mogu dati i kako se sve to radi. Započnimo.

Cast u aritmetičkim izrazima izvodi se automatski.

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

Ako se operandi a i b kombiniraju binarnim operatorom (o tome ćemo raspravljati u nastavku), prije njegovog izvršenja oba se operanda pretvaraju u isti tip podataka kako slijedi:

• 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đer pretvara u int;

Dopuštene pretvorbe tipa

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

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

Predlažem da napravite nekoliko primjera.

Možda ste malo krivo razumjeli ovaj kod budući da još nisam objasnio što su kompajler, konstante itd. Kasnije na treningu sve ću vam reći, iako sam to trebao učiniti ranije. A sada želim opisati koja bi pravila trebala imati imena varijabli.

• Imena varijabli ne mogu započ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 prvo mjesto i ime.
• Varijabla primitivnog tipa deklarirana kao član klase (globalna varijabla) postavljena je na nulu prema zadanim postavkama.
• Ako je varijabla deklarirana kao lokalna varijabla u metodi, mora se inicijalizirati prije upotrebe. Budući da lokalne varijable nisu inicijalizirane prema zadanim postavkama. To znači da ne možete deklarirati lokalnu varijablu i ostaviti je neinicijaliziranu. To jest, ovako: int i;. Ako to učinite u metodi, prevodilac će od vas tražiti da postavite zadanu vrijednost, dok će je prilikom kreiranja takve varijable kao člana klase (globalne) sam prevodilac postaviti na 0.
• Opseg i životni vijek varijable ograničeni su blokom () u kojem je deklarirana. Ako ste stvorili varijablu unutar metode (kao što smo učinili u primjerima), tada je ne možete koristiti izvan metode, jer je metoda omeđena zagradama (). Globalna varijabla vidljiva je u svim blokovima.
• Također je zabranjeno koristiti rezervirano java riječi. Cijeli popis ključne riječi može se vidjeti na slici ispod.

A budući da sam u ovom članku dotaknuo izraz binarni operator, predlažem da razmotrimo operatore u Javi. Štoviše, nema puno teorije.

Java ima nekoliko tipova operatora: jednostavne operatore dodjele, aritmetičke, unarne, jednake i relacijske, uvjetne, usporedbe tipova, bitwise i bitshift.

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

U početku ćemo koristiti bitovnu usporedbu, dodjelu i postfiksne operatore. Drugi operatori nisu tako česti, pa ćemo razmotriti samo one koje ćemo koristiti.

javna klasa OperatoriInJava (

int a = 5;

int b = 6;

int zbroj = a + b;

int razlika = a - b;

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

Prilagodba tipa može biti eksplicitna ili automatska.

Kod eksplicitnog pretvaranja tipa, sama operacija pretvaranja je specificirana eksplicitno.

Prilikom izvođenja automatskog lijevanja moraju biti ispunjena dva uvjeta:

• obje vrste moraju biti kompatibilne;
• duljina izvorni tip(vrsta izvora) mora biti manja od duljine vrsta cilja(vrsta prijemnika).

2. Kako eksplicitno pretvaranje tipa izgleda u izrazima? Primjeri

Eksplicitno pretvaranje tipa dopušta dodjelu nekompatibilnih tipova. Opći obrazac Eksplicitno pretvaranje tipa izgleda ovako:

(target_type) vrijednost

target_type– ovo je tip na koji želite pretvoriti navedeno značenje.

Primjeri eksplicitno lijevanje tipa.

// eksplicitno pretvaranje tipa u izraze bajt b; int a; dvostruko d; plovak 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 - skrati vrijednost a = -27; b = (bajt)a; // b = -27

3. Primjeri automatskog lijevanja slova

Primjer 1. Automatsko lijevanje cjelobrojnih tipova.

// automatsko određivanje cjelobrojnih 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: "Neusklađenost 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 = netočno; //a = b1; - pogreška, vrste su nekompatibilne

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

// automatsko pretvaranje tipova s ​​pomičnim zarezom plovak f; dvostruko d; f = 3,409033f; d = f; // d = 3,409033

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

// automatsko lijevanje mješovitih tipova plovak f; dvostruko d; a = 28; d = a; // d = 28,0 f = a; // f = 28,0 // Pogreška: Neusklađenost tipa: nije moguće pretvoriti iz float u int // a = f;

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

Automatsko unapređenje tipa događa se u izrazima. U ovom slučaju, vrijednosti koje se pojavljuju u izrazima automatski se promiču u tipove s velikim rasponima vrijednosti.

Prilikom automatskog promoviranja tipova u izrazima:

• ako je jedan od cijelih operanda tipa int, tada se sve vrijednosti tipa byte, short i char promiču u tip int;
• ako je jedan od cijelih operanda tipa long, tada se cijeli izraz promiče u tip long;
• ako se jedan od operanda odnosi na tip plovka, onda će tip cijelog izraza također biti tipa float (ako nema operanda tipa double);
• ako je jedan od operanda tipa double, tada će tip cijelog izraza također biti double.

5. Primjer promicanja iz tipa byte u int u kojem izraz ne sadrži varijable operanda tip int(dugo)

// bajt -> int bajt b; b = 1000/20; // b = 50, radi jer je rezultat smješten u tip bajta

Gornji primjer radi ispravno jer:

• rezultat je smješten (kompatibilan) u tip bajta;
• nema operanda tipa int.

U gornjem primjeru, vrijednost 1000 prelazi raspon vrijednosti bajtova. Prvo se broj 1000 pretvara u tip int. Ali rezultat

1000 / 20 = 50

pretvara se u bajt i može ispravno stati u varijablu b .

Ako to napišeš ovako:

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

tada će se pojaviti pogreška kompilacije s 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 generirati poruku o pogrešci.

Ako izvršite eksplicitno pretvaranje tipa:

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

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

Gornji primjeri također se odnose na varijable tipova short i char.

6. Primjer. Promicanje iz bajta u int gdje izraz sadrži operand varijable 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 tip int. Stoga će kompajler proizvesti poruku o pogrešci:

Neusklađenost tipa: ne može se pretvoriti iz int u bajt

To znači da je rezultat int (ne bajt) čak i ako vrijednost stane unutar raspona vrijednosti bajta. Budući da izraz koristi varijablu operanda d tip int.

Ako izvršite eksplicitno pretvaranje 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. Promaknuće s int na long

Primjer promicanja tipa iz int u long. Ako je jedan od operanda tipa long, tada se cijeli izraz promiče u tip long.

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

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

Ponekad se pojave situacije kada imate vrijednost neke određena vrsta, ali ga trebate dodijeliti varijabli druge vrste. Za neke tipove to se može učiniti bez pretvaranja tipa; u takvim slučajevima govore o automatskoj pretvorbi tipa. U Javi je automatska konverzija moguća samo ako je numerički prikaz odredišne ​​varijable dovoljno točan za pohranjivanje izvorne vrijednosti. Takva se konverzija događa npr. prilikom unosa literalne konstante ili vrijednosti varijable tipa byte ili short u varijablu tipa int. To se zove proširenje (širenje) ili povećati (promocija), jer se niži bitni tip proširuje (promovira) u veći kompatibilni tip. Veličina tipa int uvijek je dovoljna za pohranjivanje brojeva iz raspona koji dopušta tip byte, tako da in slične situacije Eksplicitni operator pretvaranja tipa nije potreban. Obrnuto nije točno u većini slučajeva, pa da biste dodijelili vrijednost tipa int varijabli tipa byte, morate koristiti operator cast tipa. Taj se postupak ponekad naziva sužavanje (sužavanje), jer eksplicitno kažete prevoditelju da se vrijednost mora pretvoriti da bi stala u varijablu željenog tipa. Za pretvaranje vrijednosti u određeni tip, ispred njega navedite taj tip, u zagradama. Sljedeći isječak koda demonstrira pretvaranje tipa izvora (varijabla int) u tip odredišta (varijabla bajta). Ako je tijekom takve operacije vrijednost cijelog broja bila izvan raspona dopuštenog za tip bajta, smanjila bi se modulo dijeljenjem s rasponom dopuštenim za bajt (rezultat modulo dijeljenja brojem je ostatak dijeljenja s taj broj),

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

2.2.1. Automatska pretvorba tipa 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 dopuštenih za tip bajta. Zbog toga Java automatski promiče tip svakog dijela izraza u tip int, tako da ima dovoljno mjesta za međurezultat (a* b).

Automatska pretvorba tipa ponekad može uzrokovati neočekivane poruke pogreške prevoditelja. 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 varijablu bajta. Ali zbog automatske pretvorbe tipa rezultata u int, primamo poruku o pogrešci od prevoditelja - na kraju krajeva, kod pisanja int u bajt može doći do gubitka preciznosti.

bajt b = 50;
b = b* 2:
^ Nekompatibilna vrsta za =. Eksplicitno pretvaranje potrebno za pretvaranje in u bajt.
(Nekompatibilna vrsta za =. Potrebna je eksplicitna konverzijaintbajt)

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

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

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

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

klasa Promocija (
public static void main (String args) (
bajt b= 42;
pougljeniti sa= "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 njegov tip automatski promiče u float. Tip sljedećeg podizraza i/c (int podijeljen sa char) je unaprijeđen u int. Isto tako, tip podizraza d*s (double times short) je promaknut u double. U sljedećem koraku izračuna bavimo se s tri međurezultata tipa float, int i double. Prvo, kada se dodaju prva dva, tip int se promovira u float i rezultat je float. Kada se od toga 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 brojeve, znakove i booleove, pokušajmo to sve staviti zajedno. Primjer u nastavku stvara varijable za svaku od jednostavne vrste 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;
pougljeniti sa= 'a';
plovak f= .25f;
dvostruko 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("dugi 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 trebali biste dobiti rezultat prikazan u nastavku:

bajt b = 85
kratke hlače = 22015
int i = 1000000
dugo 1 = 4294967295
pougljeniti sa=a
plovak f = 0,25
dvostruko d=1.234e-005
boolean boolean = istina

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

Zadnja izmjena: 29.10.2018

Svaki osnovni tip podaci zauzimaju određeni broj bajtova memorije. To postavlja ograničenje na operacije koje uključuju Različite vrste podaci. Razmotrite sljedeći primjer:

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

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

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

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

Operacija pretvorbe 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 pretvaraju se u tip byte. Kao rezultat, dobit ćemo vrijednost tipa byte.

Eksplicitne i implicitne pretvorbe

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

Automatske pretvorbe

Strelice na slici pokazuju koje se tipske pretvorbe mogu izvesti automatski. Točkaste strelice prikazuju automatske pretvorbe s gubitkom točnosti.

Automatski proizveden bez ikakvih problema širenje transformacija(proširivanje) - proširuju prikaz objekta u memoriji. Na primjer:

Bajt b = 7; int d = b; // pretvorba 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 -> dvostruko

kratko -> plutajuće -> dvostruko

char -> int

Automatske pretvorbe s gubitkom preciznosti

Neke pretvorbe mogu se izvesti automatski između tipova podataka iste širine bita ili čak iz tipa podataka veće širine bita u tip s manjom širinom bita. To su sljedeći lanci konverzija: int -> float, long -> float i long -> double izvode se bez grešaka, ali tijekom 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 ostale pretvorbe primitivnih tipova eksplicitno primjenjuju operaciju pretvorbe tipa. Obično su to sužavanje konverzija iz tipa s većom širinom bita u tip s manjom širinom bita:

Dugi a = 4; int b = (int) a;

Gubitak podataka tijekom konverzije

Kada koristimo eksplicitne pretvorbe, 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 dobro se uklapa u raspon vrijednosti bajtova, tako da će nakon pretvorbe varijabla b biti jednaka 5. Ali što 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 raspona za tip bajta (od -128 do 127), pa će vrijednost biti skraćena. Zašto će rezultat biti broj 2?

Broj a, koji je 258, u binarni sustav bit će jednako 00000000 00000000 00000001 00000010 . Vrijednosti bajtova zauzimaju samo 8 bita memorije. Zato binarni prikaz int broj je skraćen udesno za 8 znamenki, to jest, 00000010, što u decimalni sustav daje broj 2.

Skraćivanje racionalnih brojeva na cijele brojeve

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

Dvostruki 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, morate koristiti funkciju zaokruživanja, koja je dostupna u matematička knjižnica Java:

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

Transformacije tijekom operacija

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

ako je jedan od operanda operacije tipa double, tada se drugi operand pretvara u tip double

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

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

inače se svi operandi operacije pretvaraju u tip int

Primjeri transformacija:

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

Budući da operacija uključuje dvostruku vrijednost, i druga vrijednost se pretvara u dvostruki tip i zbroj dviju vrijednosti a+b će predstavljati dvostruki tip.

Još jedan primjer:

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

Dvije varijable su tipa byte i short (nisu double, float ili long), pa kada se dodaju pretvaraju se u tip int, a njihov zbroj a+b predstavlja int vrijednost. Prema tome, ako dodijelimo ovaj iznos varijabli tipa byte, onda opet moramo izvršiti pretvorbu tipa u byte.

Ako operacije uključuju podatke tipa char, onda se pretvaraju u int:

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