Conversia double în int java. Tastați Conversie în Java

Uneori apar situații când aveți o valoare de un anumit tip și trebuie să o atribuiți unei variabile de alt tip. Pentru unele tipuri, acest lucru se poate face fără turnare de tip; în astfel de cazuri se vorbește despre conversia automată a tipului. În Java, conversia automată este posibilă numai dacă reprezentarea numerică a variabilei de destinație este suficient de precisă pentru a stoca valoarea inițială. O astfel de conversie are loc, de exemplu, când se introduce o constantă literală sau valoarea unei variabile de tip octet sau scurt într-o variabilă de tip int. Se numeste extensie (lărgirea) sau crește (promovare), deoarece un tip de biți mai mici este extins (promovat) la un tip compatibil mai mare. Mărimea tipului int este întotdeauna suficientă pentru a stoca numere din intervalul permis de tipul de octet, deci în situatii similare Nu este necesar un operator de distribuție de tip explicit. Reversul nu este adevărat în majoritatea cazurilor, așa că pentru a atribui o valoare de tip int unei variabile de tip octet, trebuie să utilizați operatorul tip cast. Această procedură este uneori numită îngustare (îngustarea), pentru că îi spuneți în mod explicit traducătorului că valoarea trebuie convertită pentru a se potrivi într-o variabilă de tipul dorit. Pentru a arunca o valoare într-un anumit tip, precedați-o prin specificarea tipului respectiv, cuprins între paranteze. Următorul fragment de cod demonstrează turnarea tipului unei surse (o variabilă int) la tipul unei destinații (o variabilă octet). Dacă, în timpul unei astfel de operații, valoarea întregului se afla în afara intervalului permis pentru tipul de octet, aceasta ar fi redusă prin împărțirea modulo la intervalul permis pentru octet (rezultatul împărțirii modulo cu un număr este restul divizării la acel număr),

int a = 100;
octetb = (octet) a;

2.2.1. Conversie automată a tipurilor în expresii

Când se calculează valoarea unei expresii, precizia necesară pentru stocarea rezultatelor intermediare trebuie să fie adesea mai mare decât cea necesară pentru a reprezenta rezultatul final.

octet a = 40;
octet b = 50;
octet cu = 100;
int d = a* b / c;

Rezultatul expresiei intermediare (a*b) poate fi în afara intervalului de valori permis pentru tipul de octet. Acesta este motivul pentru care Java promovează automat tipul fiecărei părți a unei expresii pentru a tasta int, astfel încât să existe suficient spațiu pentru rezultatul intermediar (a* b).

Conversia automată a tipurilor poate provoca uneori mesaje de eroare neașteptate ale traducătorului. De exemplu, codul prezentat mai jos, deși pare destul de corect, are ca rezultat un mesaj de eroare în timpul fazei de traducere. În el încercăm să scriem valoarea 50*2, care ar trebui să se potrivească perfect în tipul de octet, într-o variabilă de octet. Dar pentru că conversie automată tip de rezultat în int, primim un mesaj de eroare de la traducător - la urma urmei, atunci când scrieți un int într-un octet, poate apărea o pierdere de precizie.

octet b = 50;
b = b* 2:
^ Tip incompatibil pentru =. Este necesară transformarea explicită pentru a converti int în octet.
(Tip incompatibil pentru =. Este necesară conversia explicităint înoctet)

Text corectat:
octetb = 50;
b = (octet) (b* 2);

ceea ce face ca b să fie setat la valoarea corectă 100.

Dacă o expresie folosește variabile de tipul byte, short și int, atunci tipul întregii expresii este promovat automat la int pentru a evita overflow. Dacă într-o expresie tipul a cel puțin unei variabile este lung, atunci și tipul întregii expresii este ridicat la lung. Amintiți-vă că toate literalele întregi care nu se termină cu un L (sau 1) sunt de tip int.

Dacă expresia conține operanzi tip plutitor, atunci tipul întregii expresii este ridicat automat pentru a pluti. Dacă cel puțin unul dintre operanzi este de tip double, atunci tipul întregii expresii este ridicat la dublu. În mod implicit, Java tratează toate literalele în virgulă mobilă ca fiind de tip double. Următorul program arată cum este promovat tipul fiecărei valori dintr-o expresie pentru a se potrivi cu al doilea operand al fiecărui operator binar.

Promovarea clasei (
public static void main (Argumente șir) (
octet b= 42;
char cu= „a’;
pantaloni scurți = 1024;
int i = 50000;
float f = 5,67f;
dublat =.1234;
rezultat dublu = (f*b) + (i/ c) - (d* s);
Sistem, afară. println ((f* b)+ "+ "+ (i / c)+ " -" + (d* s));
Sistem, afară. println("rezultat = "+ rezultat); )
}

Subexpresia f*b este un float înmulțit cu un octet, astfel încât tipul său este promovat automat la float. Tipul următoarei subexpresii i/c (int împărțit la char) este promovat la int. De asemenea, tipul subexpresiei d*s (dublu ori scurt) este promovat la dublu. În următorul pas al calculelor, ne ocupăm de trei rezultate intermediare de tipurile float, int și double. În primul rând, la adăugarea primelor două, tipul int este promovat la float și rezultatul este un float. Când o valoare dublă este scăzută din aceasta, tipul de rezultat este promovat la dublu. Rezultatul final al întregii expresii este o valoare dublă.

Acum că am văzut toate tipurile simple, inclusiv numere întregi, numere reale, caractere și booleeni, să încercăm să le punem pe toate cap la cap. Exemplul de mai jos creează variabile pentru fiecare dintre tipuri simple iar valorile acestor variabile sunt afișate.

clasa SimpleTypes (
public static void main(Argumente șir) (
octet b = 0x55;
s scurt = 0x55ff;
int i = 1000000;
lung l = 0xffffffffL;
char cu= 'a';
float f= .25f;
dublu d = .00001234;
boolean bool = adevărat;
System.out.println("byte b = " + b);
System.out.println("short s = " +s);
System.out.println("int i =” + i);
System.out.println("long 1 = " + l);
System.out.println("car cu=” + s);
System.out.println("float f = " + f);
System.out.println("double d = " + d);
System.out.println("boolean bool =” + bool); )
}

Prin rularea acestui program ar trebui să obțineți rezultatul prezentat mai jos:

octet b = 85
pantaloni scurți = 22015
int i = 1000000
lung 1 = 4294967295
char cu=a
float f = 0,25
dublu d=1,234e-005
boolean boolean = adevărat

Vă rugăm să rețineți că numerele întregi sunt tipărite în notație zecimală, deși am specificat valorile unora dintre ele în notație hexazecimală.

Java este un limbaj de programare puternic tipizat, ceea ce înseamnă că fiecare expresie și fiecare variabilă are un strict anumit tip deja la momentul compilarii.
Tipuri de fantome
Java oferă șapte tipuri de distribuții:

• Identic (identitate);


• lărgirea primitivă;


• Îngustare primitivă;


• Referință de extindere a tipului de obiect;


• Referință de îngustare;


• Convertiți în șir;


• Transformări interzise (interzise);

Să le privim separat.
Transformarea identității
Cea mai simplă este transformarea identităţii. În Java, conversia unei expresii de orice tip în exact același tip este întotdeauna validă și are succes.
Acest lucru este important pentru a putea afirma din punct de vedere teoretic că orice tip în Java poate participa la conversie, cel puțin la o conversie de identitate.
Conversie de tip primitiv (expansiune și contracție)
Pentru tipurile simple, extinderea înseamnă că se face o tranziție de la un tip mai puțin încăpător la unul mai încăpător. De exemplu, de la tipul octet (lungime de 1 octet) la tipul int (lungime de 4 octeți). Astfel de transformări sunt sigure în sensul că tip nou este întotdeauna garantat că va conține toate datele care au fost stocate în vechiul tip și, prin urmare, nu există nicio pierdere de date. De aceea, compilatorul îl implementează singur, neobservat de dezvoltator:

octet b=3;
int a=b;

Următoarele 19 transformări sunt de expansiune:

• De la octet la scurt, int, long, float, double


• De la scurt la int, long, float, double


• De la char la int, long, float, double


• De la int la lung, float, double


• De la lung la plutitor, dublu


• De la float la dublu

Vă rugăm să rețineți că nu puteți converti în char de la tipuri mai mici de sau lungime egală(octet, scurt) sau, dimpotrivă, scurtcircuitare de la char fără pierdere de date. Acest lucru se datorează faptului că char, spre deosebire de alte tipuri de numere întregi, este semnat.
Cu toate acestea, trebuie amintit că, chiar și cu extinderea, datele pot fi încă distorsionate. Acestea sunt turnarea valorilor int la float și a valorilor lungi la float sau la dublare. Deși aceste tipuri fracționale găzduiesc mult numere mari, decât numerele întregi corespunzătoare, dar au mai puține cifre semnificative.
De exemplu:

a lung = 111111111111L;
float f=a;
a=(lung)f; // () aceasta este exact operația de conversie a tipului
System.out.println(a); //rezultat 111111110656

Vă rugăm să rețineți că îngustarea înseamnă că tranziția este de la un tip mai încăpător la unul mai puțin încăpător. Cu această conversie există riscul pierderii datelor. De exemplu, dacă un număr int a fost mai mare de 127, atunci când îl convertiți într-un octet, se vor pierde valorile biților mai mari decât al optulea. În Java, o astfel de conversie trebuie făcută în mod explicit, adică. Programatorul trebuie să indice în mod explicit în cod că intenționează să efectueze o astfel de conversie și este pregătit să piardă date.
Următoarele 23 de transformări se îngustează:

• De la octet la caracter


• De la scurt la octet, char


• De la caracter la octet, scurt


• De la int la octet, scurt, char


• De la lung la octet, scurt, char, int


• De la float la octet, short, char, int, long


• De la dublu la octet, scurt, char, int, long, float

Când restrângeți un tip întreg la un tip întreg mai îngust, toți biții de ordin înalt care nu se încadrează în noul tip sunt pur și simplu aruncați. Nu se efectuează rotunjiri sau alte acțiuni pentru a obține un rezultat mai corect:

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

Rezultatul va fi:

127
-128
-128
Se poate observa că bitul de semn nu a avut niciun efect în timpul îngustării, deoarece a fost pur și simplu aruncat - rezultatul aducerii numerelor reciproce (384, -384) s-a dovedit a fi același. În consecință, nu numai valoarea absolută exactă se poate pierde, ci și semnul mărimii.
Acest lucru este valabil și pentru char:

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

Rezultat:

-25536
Conversie tip de referință (extindere și contracție)
Conversia tipului de obiect este cel mai bine ilustrată folosind un arbore de moștenire. Să ne uităm la un mic exemplu de moștenire:

clasa Parinte(
int x;
}

clasa ChildY extinde Parent (
int y;
}

clasa ChildZ extinde Parent (
int z;
}

Fiecare clasă declară un câmp cu un nume unic. Vom considera acest câmp ca un exemplu de set de proprietăți unice inerente unui tip de obiect.
Obiectele clasei Parent au un singur câmp x, ceea ce înseamnă că numai referințele de tip Parent se pot referi la astfel de obiecte. Obiectele clasei ChildY au un câmp y și un câmp x, moștenite de la clasa Părinte. Prin urmare, astfel de obiecte pot fi indicate prin referințe de tip ChildY sau Parent. Exemplu:

Părinte p = nou CopilY();

Rețineți că o astfel de referință p poate accesa doar câmpul x al obiectului creat. Câmpul y nu este disponibil deoarece compilatorul, la verificarea validității expresiei p.y, nu poate prezice că referința p va indica un obiect de tip ChildY în timpul execuției. Analizează doar tipul variabilei în sine și este declarată ca Parent, dar această clasă nu are câmpul y, ceea ce va cauza o eroare de compilare.
În mod similar, obiectele clasei ChildZ au un câmp z și un câmp x derivat din clasa Părinte. Aceasta înseamnă că astfel de obiecte pot fi indicate prin link-uri precum ChildZ și Parent.
Astfel, referințele de tip Parent pot indica un obiect din oricare dintre cele trei tipuri luate în considerare, dar referințele de tip ChildY și ChildZ pot indica doar obiecte de exact același tip. Acum putem trece la conversia tipurilor de referință pe baza acestui arbore de moștenire.
Extinderea înseamnă trecerea de la un tip mai specific la un tip mai puțin specific, adică. trecerea de la copii la părinți. Similar cu cazul cu tipuri primitive, această tranziție este făcută chiar de JVM dacă este necesar și este „invizibilă” pentru dezvoltator, adică nu necesită transformări speciale.

Părinte p1=copil nou Y();
Părinte p2=nou CopilZ();

În ambele linii, variabilelor de tip Parent li se atribuie o valoare de alt tip, ceea ce înseamnă că are loc o conversie. Deoarece aceasta este o extensie, se face automat și are întotdeauna succes.
Trebuie remarcat faptul că în timpul unei astfel de transformări nu se întâmplă nimic obiectului în sine. Chiar dacă, de exemplu, câmpul y al clasei ChildY nu mai este disponibil, asta nu înseamnă că a dispărut. O astfel de schimbare semnificativă a obiectului nu este posibilă. A fost derivat din clasa ChildY și își păstrează toate proprietățile. S-a schimbat doar tipul de link prin care este accesat obiectul.
Tranziția inversă, adică deplasarea în jos a arborelui moștenire către moștenitori, este o îngustare. De exemplu, în acest caz, trecerea de la o referință de tip Parent, care se poate referi la obiecte din trei clase, la o referință de tip ChildY, care se poate referi doar la una dintre cele trei clase, este evident o îngustare. O astfel de tranziție ar putea să nu fie posibilă. Dacă o referință de tip Parent se referă la un obiect de tip Parent sau ChildZ, atunci o tranziție la ChildY nu este posibilă, deoarece în ambele cazuri obiectul nu are un câmp y, care este declarat în clasa ChildY. Prin urmare, atunci când se îngustează, designerul trebuie să indice în mod explicit că este necesar să încerce o astfel de transformare. JVM-ul va verifica dacă tranziția este corectă în timpul execuției. Dacă este posibil, conversia va fi efectuată. Dacă nu, va apărea o eroare (de obicei o ClassCastException).

Părinte p=nou CopilY();
ChildY cy = (ChildY)p; //dreapta
Părinte p2=nou CopilZ();
ChildY cy2 = (ChildY)p2; //eroare

Pentru a verifica dacă tranziția dorită este posibilă, puteți utiliza operatorul instanceof:

Părinte p=nou CopilY();
dacă (p exemplu de ChildY) (
ChildY cy = (ChildY)p;
}

Părinte p2=nou CopilZ();
dacă (p2 instanță ChildY) (
ChildY cy = (ChildY)p2;
}

Parent p3=new Parent();
dacă (p3 instanță de ChildY) (
ChildY cy = (ChildY)p3;
}

ÎN în acest exemplu nu vor apărea erori. Prima transformare este posibilă și se va realiza. În al doilea și al treilea caz, condițiile declarațiilor if nu vor funcționa și, prin urmare, nu va exista o tranziție incorectă.
Conversie în șir
Orice tip poate fi turnat într-un șir, de ex. a copia clasa String. Această transformare este excepțională datorită faptului că acoperă absolut toate tipurile.
Diferitele tipuri sunt convertite în șir, după cum urmează:

• Tipurile numerice sunt scrise în forma text fără pierderea acurateței prezentării. Mai întâi, o instanță a clasei „wrapper” corespunzătoare este generată pe baza valorii primitive, apoi este apelată metoda sa toString(). Dar, deoarece aceste acțiuni sunt invizibile din exterior, JVM-ul le optimizează și le convertește valorile primitive direct în text.


• Valorile booleene sunt turnate în șirul „adevărat” sau „fals”, în funcție de valoare.


• Pentru valorile obiectului, este apelată metoda toString(). Dacă metoda returnează null, rezultatul va fi șirul „null”.


• Pentru o valoare nulă, este generat șirul „null”.

Transformări interzise
Nu sunt permise toate tranzițiile între tipurile arbitrare. De exemplu, conversiile interzise includ: tranzițiile de la orice tip de referință la un tip primitiv și invers (cu excepția conversiei într-un șir), booleanul poate fi turnat numai în acest tip sau într-un șir. În plus, este imposibil să aduceți clasele situate pe ramurile adiacente ale arborelui moștenire una la alta. În exemplul folosit pentru a ilustra tipurile de referință, trecerea de la ChildY la ChildZ este interzisă.
Această listă de transformări interzise nu se termină aici. Este destul de larg și în același timp toate opțiunile sunt destul de evidente, așa că nu vor fi discutate în detaliu. Cei care doresc pot primi informatii complete din caietul de sarcini.
Desigur, încercarea de a efectua o conversie ilegală va provoca o eroare.

Utilizarea gipsurilor
Situațiile de utilizare a conversiei de tip pot fi grupate după cum urmează:

• Atribuirea de valori variabilelor (atribuire). Nu toate tranzițiile sunt permise în timpul acestei transformări - restricțiile sunt alese astfel încât să nu poată apărea o excepție.


• Apel de metodă. Această conversie se aplică argumentelor metodei sau constructorului numit. O astfel de distribuție nu produce niciodată erori. Turnarea se efectuează și atunci când valoarea metodei este returnată.


• Casting explicit. În acest caz, este indicat în mod explicit la ce tip trebuie turnată valoarea inițială.


• Operatorul de concatenare se convertește într-un șir de argumente.


• Expansiunea numerică. Operații numerice poate necesita schimbarea tipului argumentului (argumentelor). Această transformare are un nume special - extins, de la alegere tipul tinta poate depinde nu numai de valoarea inițială, ci și de al doilea argument al operației.

Sarcina #8
Adaugă la proiectul tău utilizarea casting-ului pentru ierarhia clasei.

Uneori apar situații când este necesar să se atribuie o valoare unei variabile de un tip unei variabile de alt tip. De exemplu:

Exemplul 1: Atribuirea valorii unei variabile de un tip altuia

int i = 11; octet b = 22; i = b;

Există 2 tipuri de transformări în Java - conversie automată (implicit)Și tip casting (conversie explicită).

1. Conversie automată

Să ne uităm mai întâi la conversia automată. Dacă ambele tipuri sunt compatibile, conversia lor se va face automat în Java. De exemplu, o valoare ca octet poate fi întotdeauna atribuit unei variabile precum int , așa cum se arată în exemplul 1.

Pentru conversia automată a tipului, trebuie îndeplinite două condiții:

• ambele tipuri trebuie să fie compatibile
• lungimea tipului țintă trebuie să fie mai mare decât lungimea tip original

În acest caz se întâmplă conversie cu extensie.

Următoarea diagramă arată extinderea conversiei în Java:

Liniile continue indică transformările efectuate fără pierderi de date. Liniile întrerupte indică faptul că poate apărea o pierdere de precizie în timpul conversiei.

De exemplu, tipul de date int întotdeauna suficient de mare pentru a depozita totul valori valide tip octet , deci nu există operatori de casting explicit în în acest caz, nu este necesar. Dintr-o perspectivă de conversie din ce în ce mai extinsă, tipurile de date numerice, inclusiv numere întregi și virgulă mobilă, sunt compatibile între ele. În același timp, nu există conversii automate de la tipuri numerice la tip char sau boolean . Tipuri char Și boolean sunt, de asemenea, incompatibile între ele.

Merită să explicăm puțin de ce, de exemplu tipul octet nu se convertește automat (nu explicit) în tip char , deși tip octet are 8 biți lățime și char - 16, același lucru este valabil și pentru conversia tipului mic de statura V char . Acest lucru se întâmplă pentru că octet Și mic de statura tipuri de date semnate și char nesemnat. Prin urmare, în acest caz, trebuie să utilizați un tip explicit, deoarece compilatorul trebuie să indice în mod explicit că știți ce doriți și cum va fi procesat bitul semnat de tipuri. octet Și mic de statura la conversia la tip char .

Comportamentul valorii tip char în cele mai multe cazuri coincide cu comportamentul unei valori de tip întreg, prin urmare, o valoare de tip char poate fi folosit oriunde sunt necesare valori int sau lung . Cu toate acestea, amintiți-vă că tipul char nu are semn, deci se comportă diferit de tip mic de statura , în ciuda faptului că intervalul ambelor tipuri este de 16 biți.

2. Tip turnare

În ciuda confortului conversiei automate de tip, nu este capabil să satisfacă toate nevoile presante. De exemplu, ce se întâmplă dacă valoarea este ca int trebuie atribuit unei variabile de tip octet ? Această conversie nu va fi efectuată automat din cauza lungimii tipului octet mai puțin decât tipul int . Uneori se numește acest tip de transformare îngustarea transformării, deoarece valoarea este restrânsă în mod explicit pentru a se potrivi tipului de date țintă.

Pentru a converti între două tipuri de date incompatibile, trebuie să utilizați un tip cast. O distribuție este doar o conversie explicită de tip. Forma generală Tipul de turnare arată astfel:

(tip_țintă) valoare

unde este parametrul tip_țintă indică tipul la care trebuie convertită valoarea specificată.

Exemplul 2: Tip turnare

De exemplu, în următorul fragment de cod, tipul int arunca la tip octet:

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

Exemplul 3: Conversii din virgulă mobilă în întreg

Să ne uităm la un exemplu de conversie a valorilor în virgulă mobilă în numere întregi. În acest exemplu fracțiune Valorile în virgulă mobilă sunt pur și simplu eliminate (operație de trunchiere):

dublu d = 3,89; int a = (int) d; //Rezultatul va fi 3

Exemplul 4: conversii de la un tip întreg mai mare la un tip întreg mai mic

Când turnați un tip întreg mai mare într-unul mai mic, cei mai semnificativi biți sunt pur și simplu aruncați:

Int i = 323; octet b = (octet)i; //Rezultatul va fi 67

Exemplul 5: Conversia unei valori cu virgulă mobilă mai mare într-o capacitate întreagă mai mică

Când turnați o valoare în virgulă mobilă mai mare într-un număr întreg, cei mai semnificativi biți sunt trunchiați și eliminați:

dublu d = 389889877779,89; scurt s = (scurt) d; //Rezultatul va fi -1

3. Promovarea tip automată în expresii

Pe lângă operațiunile de atribuire, anumite conversii de tip pot fi efectuate și în expresii.

ÎN limbajul Java Se aplică următoarele reguli:

1. Dacă un operand este de tip dubla dubla.
2. pluti, celălalt este, de asemenea, convertit la tip pluti.
3. În caz contrar, dacă un operand este de tip lung, celălalt este, de asemenea, convertit la tip lung.
4. În caz contrar, ambii operanzi sunt convertiți în tip int.
5. În expresiile de atribuire mixte (+=,-=,*=,/=), nu este nevoie să efectuați o distribuție.

Iată un exemplu:

Exemplul 6. Promovarea tipului automat în expresii

La înmulțirea variabilei b1 ( octet) pe 2 ( int) rezultatul va fi ca int. Prin urmare, atunci când încercați să atribuiți rezultatul variabilei b2 ( octet) va apărea o eroare de compilare. Dar atunci când utilizați operatorul de atribuire combinată (*=), această problemă nu va apărea.

Octet b1 = 1; octet b2 = 2 * b1; //Eroare de compilare int i1 = 2 * b1; b2 *= 2;

Exemplul 7. Promovarea tipului automat în expresii

ÎN exemplul următor va apărea și o eroare de compilare - în ciuda faptului că numerele ca octet, rezultatul operației va fi tipul int, dar nu mic de statura.

Clasa publică IntegerDemo1 ( public static void main(String args) ( byte b1 = 50, b2 = -99; short k = b1 + b2; //eroare de compilare System.out.println("k=" + k); ) )

Exemplul 8. Promovarea tipului automat în expresii

Acest exemplu este similar cu cel anterior, dar folosește operația de atribuire combinată, în care distribuția are loc automat.

Clasa publică IntegerDemo2 ( public static void main(String args) ( octet b1 = 50, b2 = -99; b1 += b2; System.out.println("b1=" + b1); ) )

1. Ce este explicit și turnare automată tipuri de expresii?

Turnarea tipului poate fi explicită sau automată.

Cu turnarea de tip explicit, operația de turnare în sine este specificată în mod explicit.

Când se efectuează turnarea de tip automat, trebuie îndeplinite două condiții:

• ambele tipuri trebuie să fie compatibile;
• lungimea tipului sursă (tipul sursă) trebuie să fie mai mică decât lungimea tipului țintă (tipul chiuvei).

2. Cum arată turnarea de tip explicit în expresii? Exemple

Castingul explicit de tip permite alocarea de tipuri incompatibile. Forma generală de turnare de tip explicit este:

(tip_țintă) valoare

tip_țintă– acesta este tipul la care doriți să turnați conținutul specificat sens.

Exemple turnare de tip explicit.

// turnarea explicită a tipului în expresii octetul b; int a; dublu d; plutitor f; d = -39,9203; a = (int )d; // a = -39 f = (float )d; // f = -39,9203 b = (octet )d; // b = -39 d = 302930932; b = (octet )d; // b = -12 - trunchiază valoarea a = -27; b = (octet)a; // b = -27

3. Exemple de turnare tip automat

Exemplul 1. Turnare automată a tipurilor întregi.

// turnare automată a tipurilor întregi int a; octetul b; sh scurt; b = -23; a = b; // a = -23 - turnare de tip automat sh = -150; a = sh; // a = -150 lung l = 200; // Eroare: „Nepotrivire tip: nu se poate converti de la long la int” // a = l; l = b; // l = -23 l = sh; // l = -150 char c = "Z" ; a = c; // a = 90 - cod de caractere „Z” boolean b1 = fals ; //a = b1; - eroare, tipurile sunt incompatibile

Exemplul 2. Turnare automată a tipurilor în virgulă mobilă.

// turnare automată a tipurilor în virgulă mobilă plutitor f; dublu d; f = 3,409033f; d = f; // d = 3,409033

Exemplul 3. Turnare automată tipuri mixte. Acest caz este posibil dacă unei variabile în virgulă mobilă i se atribuie valoarea unei variabile de tip întreg.

// turnare automată a tipurilor mixte plutitor f; dublu d; a = 28; d = a; // d = 28,0 f = a; // f = 28,0 // Eroare: Tip nepotrivire: nu se poate converti de la float la int // a = f;

4. Cum se face promovarea automată în expresii?

Promovare automată tipurile apare în expresii. În acest caz, valorile care apar în expresii sunt promovate automat la tipuri cu intervale mari de valori.

Când promovați automat tipurile în expresii:

• dacă unul dintre operanzii întregi este de tip int, atunci toate valorile de tip byte, short și char sunt promovate la tipul int;
• dacă unul dintre operanzii întregi este de tip long, atunci întreaga expresie este promovată la tipul long;
• dacă unul dintre operanzi este de tip float, atunci și tipul întregii expresii va fi de tip float (dacă nu există operanzi de tip double);
• dacă unul dintre operanzi este de tip double, atunci și tipul întregii expresii va fi dublu.

5. Un exemplu de promovare de la tip byte la int în care expresia nu conține operanzi variabili de tip int (lung)

// octet -> int octetul b; b = 1000 / 20; // b = 50, funcționează deoarece rezultatul este plasat într-un tip de octet

Exemplul de mai sus funcționează corect deoarece:

• rezultatul este plasat (compatibil) în tipul octet;
• fără operanzi de tip int.

În exemplul de mai sus, valoarea 1000 depășește intervalul de valori ale octeților. În primul rând, numărul 1000 este turnat pentru a tasta int. Dar rezultatul

1000 / 20 = 50

este turnat la octet și se poate potrivi corect într-o variabilă b .

Daca o scrii asa:

octetul b; b = 100000 / 20; // eroare deoarece rezultatul nu se încadrează în tipul de octet

atunci va apărea o eroare de compilare cu mesajul:

În acest caz, rezultatul nu este introdus în tipul de octeți:

100000 / 20 = 5000

Apoi acest număr (5000) devine automat un tip int și compilatorul va genera un mesaj de eroare.

Dacă faceți o distribuție de tip explicit:

octetul b; b = (octet) (100000 / 20); // b = -120

apoi în acest caz rezultatul 5000 de tip int se transformă în tip byte. După cum știți, o variabilă de tip int ocupă 32 de biți, iar o variabilă de tip byte ocupă 8 biți. Valoarea unei variabile int este trunchiată. Și avem ceea ce avem (b = -120).

Exemplele de mai sus se aplică și la tipuri de variabile scurt și char.

6. Exemplu. Promovare de la octet la int unde expresia conține un operand variabil int

// promovarea tipurilor în expresii // octet -> int octetul b; int d; d = 20; // eroare, rezultatul este de tip int, deoarece variabila d este de tip int // b = 1000 / d;

În exemplul de mai sus, expresia folosește o variabilă d tastați int. Prin urmare, compilatorul va produce un mesaj de eroare:

Nepotrivire de tip: nu se poate converti de la int la octet

Aceasta înseamnă că rezultatul este un int (nu un octet) chiar dacă valoarea se încadrează în intervalul de valori ale octetului. Deoarece expresia folosește o variabilă operand d tastați int.

Dacă efectuați o distribuție de tip explicit, rezultatul va fi corect:

// promovarea tipurilor în expresii // octet -> int octetul b; int d; d = 20; b = (octet)(1000/d); // b = 50 - funcționează corect

7. Exemplu. Promovare de la int la long

Un exemplu de promovare de tip de la int la long. Dacă unul dintre operanzi este de tip lung, atunci întreaga expresie este promovată la tip lung.

int d; lung; d = 10000 * 200; // lucrări, d = 2000000 // Eroare! Nepotrivire de tip: nu se poate converti de la long la int // d = 1L * 2L; - operanzii 1L și 2L sunt de tip lung l = 100; // eroare, unul dintre operanzi este de tip lung // d = l * 2;

După cum se poate vedea din exemplu, dacă unul dintre operanzi este de tip lung, atunci întreaga expresie devine de tip lung.