Digita la conversione in java. Conversione automatica del tipo nelle espressioni

Questo articolo:

• scritto dalla squadra Speriamo che ti sia utile. Buona lettura!
• questo è uno degli articoli della nostra

La conversione dei tipi è un argomento che può sembrare scoraggiante per i principianti con la programmazione Java. Tuttavia, ti assicuriamo che in realtà è semplice. La cosa principale da capire da quali leggi si verifica l'interazione tra le variabili e ricordalo quando scrivi programmi. Quindi cerchiamo di capirlo.

Esistono 2 tipi di trasformazioni in Java: un'immagine per aiutarti:

Ricordiamo che l'intero Universo Java è costituito da:

• tipi primitivi (byte, short, int, long, char, float, double, boolean)
• oggetti

In questo articolo, noi:

• considerare la conversione del tipo per i tipi di variabili primitive
• la conversione di oggetti (Stringa, Scanner, ecc.) non è considerata in questo articolo, poiché si verifica una "magia" separata con gli oggetti: questo è un argomento per un articolo separato.

Conversione automatica

Bene, bene, proviamo a capire cos'è la "conversione automatica".

Ricorda, quando abbiamo esaminato i tipi di variabili (nell'articolo), abbiamo detto che una variabile è una sorta di "contenitore" , che può memorizzare il valore per un uso successivo nel programma. Abbiamo anche parlato del fatto che ogni tipo di variabile ha il suo intervallo di valori validi e la quantità di memoria occupata. Ecco il cartello dove è stato dipinto tutto:

Quindi questo è ciò verso cui stiamo effettivamente guidando. Al fatto che non era affatto solo che ti venissero dati gli intervalli di valori consentiti e la quantità di memoria occupata 🙂

Confrontiamo, ad esempio:

1.byte e breve. byte ha un intervallo di valori validi inferiore rispetto a short. Cioè, byte è come una casella più piccola e short è una casella più grande. E questo significa possiamo annidare il byte in breve.

2.byte e int. byte ha un intervallo più piccolo di valori validi rispetto a int. Cioè, byte è come una scatola più piccola e int è una scatola più grande. E questo significa possiamo annidare byte in int.

3. int e long. int ha un intervallo di valori validi più piccolo rispetto a long. Cioè, int è come una scatola più piccola e long è una scatola più grande. E questo significa possiamo annidare int in long.

Questo è un esempio di conversione automatica. Questo può essere schematicamente rappresentato sotto forma di un'immagine come questa:

Vediamo come funziona in pratica.

Esempio 1

Codice numero 1 - se esegui questo codice sul tuo computer,

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

prova di classe ( byte a = 15; byte b = a;

Codice numero 2: se esegui questo codice sul tuo computer, il numero 15 verrà visualizzato nella console

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

prova di classe ( public static void main (String args) ( byte a = 15; int b = a; Sistema. fuori. println (b);

E-e-e? Pensi questo una volta che lo stesso numero è stato stampato sulla console, e il codice n. 1 differisce dal codice n. 2 solo per il tipo di variabile b quindi non c'è differenza tra loro? E non è il caso.

Il codice numero 2 contiene automaticoconversione di tipo , ma nel codice n. 1 - no:

Sebbene il numero sia, in linea di principio, lo stesso, ma ora è in b oh Un contenitore più grande che occupa più spazio su disco. Allo stesso tempo, la JVM esegue conversioni automatiche per te. lei lo sa int più di byte .

Lancio

È un'altra questione se stai cercando di trasferire qualcosa da un contenitore più grande a uno più piccolo.

Potresti sapere che il contenitore più grande contiene ciò che si adatta a quello piccolo, ma la JVM non lo sa e cerca di impedirti di commettere errori.

Pertanto, devi "dire senza mezzi termini" che la situazione è sotto controllo:

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

prova di classe ( public static void main (String args) ( int a = 0; lungo b = 15; a = (int) b;

Qui abbiamo aggiunto (int) davanti B... Se la variabile un era, per esempio, come byte, tra parentesi sarebbe (byte)... La formula generale si presenta così:

Lei dice "fai di (più) significato B una variabile del tipo (target) di cui ho bisogno int ".

Se qualcosa è andato storto.

Finora, abbiamo esaminato le situazioni, supponendo di sapere esattamente cosa stiamo facendo. Ma cosa succede se provi a mettere qualcosa in un contenitore che non ci sta?

Si scopre che solo ciò che è "adatto" rimarrà nel contenitore. Ad esempio, i numeri in virgola mobile avranno la parte frazionaria "troncata":

// esempio 1 classe Test (public static void main (String args) (double a = 11.2345; int b = (int) a; System.out.println (b); // la console otterrà il numero 11))

// Esempio 1 prova di classe ( public static void main (String args) ( doppia a = 11.2345; int b = (int) a; Sistema. fuori. println (b); // la console visualizzerà il numero 11

Va ricordato che la parte frazionaria non arrotondato, un scartato.

Cosa succede se proviamo a mettere un numero fuori portata? Ad esempio, se inserisci il numero 128 in byte (intervallo di byte da -128 a 127)? Pensi che otterremo 1? No. Otteniamo -128:

class Test (public static void main (String args) (doppio a = 128; byte b = (byte) a; System.out.println (b); // nella console vedremo -128))

Il valore di una variabile può essere calcolato con tale conversione, ma l'obiettivo del programmatore è prevenire una situazione in cui il valore esce dall'intervallo, poiché ciò può portare a un funzionamento errato del programma.

Compiti:

1. Scrivi consecutivamente nel compilatore le conversioni di tutti i tipi primitivi tra loro, inclusi i tipi char, e crea una tabella del seguente tipo:

	byte	breve	char	int	lungo	galleggiante	Doppio	booleano
byte
breve
char
int
Lungo
Galleggiante
Doppio
booleano

All'intersezione, scrivi: a - se la trasformazione avviene automaticamente, on - se devi utilizzare una trasformazione esplicita, x - se la trasformazione è impossibile.

* viene chiamato il typecasting a se stesso identico- non è necessario registrarlo

1. Guarda di nuovo la dimensione di ogni tipo primitivo. Prova a creare un diagramma a blocchi che mostri dove si adattano i tipi. Disegna le frecce che dicono trasformazione allargata e trasformazione restringente.

Domande

Durante un colloquio per la posizione di Junior Java Developer, ti potrebbe essere chiesto:

Cosa sai sulla conversione di tipi di dati primitivi, c'è perdita di dati, è possibile convertire un tipo booleano?

Prova a rispondere alla domanda.

Riassumiamo:

• Se "metti" il contenuto di un contenitore più piccolo in un contenitore più grande, la conversione è automatica e non dovrebbero verificarsi errori.

• Se è necessario inserire "un valore da un contenitore più grande in uno più piccolo", è necessario prestare attenzione e utilizzare il casting esplicito.

• Quando si converte float o double in tipi interi, la parte frazionaria non viene arrotondata, ma semplicemente scartata.
• Non viene eseguito il cast del tipo booleano su nessuno dei tipi.
• Il tipo char viene convertito in tipi numerici, così come il codice carattere UNICODE.
• Se il numero è maggiore del suo contenitore, il risultato sarà imprevedibile.

Questo articolo descrive solo una parte del materiale sul tema del typecasting. Esistono anche cast di oggetti, casting su una stringa (dopotutto, tutto può essere scritto in una stringa, giusto?) E promozione automatica del tipo nelle espressioni.

Speriamo che il nostro articolo ti sia stato utile. È anche possibile iscriversi ai nostri corsi Java a Kiev. Insegniamo da zero. Puoi trovare informazioni dettagliate sul nostro sito web.

Abbiamo concluso il nostro ultimo articolo sul fatto che avevo promesso di dirvi quali tipi possono essere lanciati e come si fa. Iniziamo.

Lancio nelle espressioni aritmetiche viene eseguito automaticamente.

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

Se gli operandi aeb sono combinati con un operatore binario (ne parleremo di seguito), prima di eseguirlo, entrambi gli operandi vengono convertiti in dati dello stesso tipo come segue:

• Se uno degli operatori è di tipo double, anche il secondo viene convertito in double;
• Se uno degli operatori è float, anche l'altro viene convertito in float;
• Se uno degli operatori è long, anche il secondo viene convertito in long;
• Se uno degli operatori è di tipo int, anche il secondo viene convertito in int;

Conversioni di tipo consentite

Le linee continue mostrano la conversione eseguita senza perdita di informazioni. Questa conversione viene eseguita implicitamente. Le conversioni in cui può verificarsi la perdita di informazioni sono chiamate casting. Sono mostrati con linee tratteggiate. Se non sono presenti righe per il tipo di dati nella figura, tale conversione è impossibile. Le trasformazioni della perdita di informazioni devono essere eseguite con molta attenzione. Quindi, come puoi perdere una parte significativa dei dati e il programma può funzionare correttamente.

Per il restringimento delle caste, deve essere esplicitato. Ad esempio: byte b = (byte) 128; assegnato int al tipo di byte.

Suggerisco di fare alcuni esempi.

Potresti non capire un po 'questo codice, dal momento che non ho ancora spiegato cos'è un compilatore, le costanti, ecc. Più avanti nel tutorial, ti dirò tutto, anche se avrei dovuto farlo prima. E ora voglio descrivere quali regole dovrebbero avere i nomi delle variabili.

• I nomi delle variabili non possono iniziare con una cifra, non possono essere utilizzati nei nomi come simboli di operatori aritmetici e logici, così come il carattere "#".
• I caratteri '$' o '_' sono accettabili, inclusa la prima posizione e il nome.
• Una variabile di tipo primitivo dichiarata come membro di una classe (variabile globale) è impostata su zero per impostazione predefinita.
• Se una variabile viene dichiarata come variabile locale in un metodo, deve essere inizializzata prima dell'uso. Poiché le variabili locali non sono inizializzate per impostazione predefinita. Ciò significa che non è possibile dichiarare una variabile locale e lasciarla non inizializzata. Cioè, in questo modo: int i ;. Se lo fai in un metodo, il compilatore ti chiederà di impostare un valore predefinito, mentre crei una tale variabile come membro di una classe (globale), il compilatore lo imposterà a 0.
• L'ambito e la durata di una variabile sono limitati dal blocco () in cui è dichiarata. Se hai creato una variabile all'interno del metodo (come abbiamo fatto negli esempi), non puoi utilizzarla al di fuori del metodo, poiché il metodo è delimitato da parentesi (). La variabile globale è visibile in tutti i blocchi.
• È inoltre vietato utilizzare le parole riservate java. L'intero elenco di parole chiave può essere visualizzato nell'immagine sottostante.

E poiché ho toccato l'espressione dell'operatore binario in questo articolo, propongo di considerare gli operatori in Java. Inoltre, non c'è tanta teoria.

Java ha diversi tipi di operatori: assegnazione semplice, aritmetica, unario, peer e relazionale, condizionale, confronto di tipo, bit per bit e offset di bit.

Ci sono molte parole intelligenti, ma questa immagine spiegherà tutto in modo molto semplice:

All'inizio utilizzeremo operatori di confronto bit per bit, assegnazione e suffisso. Altri operatori non sono così comuni, quindi prenderemo in considerazione solo quelli che utilizzeremo.

classe pubblica OperatorsInJava (

int a = 5;

intero b = 6;

int somma = a + b;

int differenza = a - b;

1. Che cos'è il typecasting esplicito e automatico nelle espressioni?

Il typecasting può essere esplicito o automatico.

Quando si esegue il cast esplicito dei tipi, l'operazione di casting stessa viene specificata in modo esplicito.

La fusione di tipo automatico richiede che siano soddisfatte due condizioni:

• entrambi i tipi devono essere compatibili;
• la lunghezza del tipo di origine (tipo di origine) deve essere inferiore alla lunghezza del tipo di destinazione (tipo di destinazione).

2. Che aspetto ha un typecasting esplicito nelle espressioni? Esempi di

Il typecasting esplicito consente l'assegnazione di tipi incompatibili. La forma generale di typecasting esplicito è:

(target_type) valore

target_type- questo è il tipo a cui vuoi trasmettere lo specificato senso.

Esempi di conversione di tipo esplicita.

// casting di tipi espliciti nelle espressioni byte b; int a; doppia d; galleggiante f; d = -39,9203; a = (int) d; // a = -39 f = (flottante) d; //f = -39,9203 b = (byte) d; // b = -39 d = 302930932; b = (byte) d; // b = -12 - tronca il valore a = -27; b = (byte) a; // b = -27

3. Esempi di conversione automatica del tipo

Esempio 1... Cast automatico di tipi interi.

// casting automatico di tipi interi int a; byte b; breve sh; b = -23; a = b; // a = -23 - casting automatico del tipo sh = -150; a = sh; // a = -150 lungo l = 200; // Errore: "Mancata corrispondenza del tipo: impossibile convertire da long a int" // a = l; l = b; // l = -23 l = sh; // l = -150 carattere c = "Z"; a = c; // a = 90 - codice carattere "Z" booleano b1 = falso; // a = b1; - errore, i tipi sono incompatibili

Esempio 2... Fusione automatica di tipi in virgola mobile.

// casting automatico di tipi in virgola mobile galleggiante f; doppia d; f = 3.409033f; d = f; // d = 3,409033

Esempio 3... Colata automatica di tipi misti. Questo è il caso se a una variabile in virgola mobile viene assegnato il valore di una variabile intera.

// colata automatica di tipi misti galleggiante f; doppia d; a = 28; d = un; // d = 28,0 f = un; //f = 28,0 // Errore: tipo non corrispondente: impossibile convertire da float a int // a = f;

4. Come viene eseguita la promozione automatica del tipo nelle espressioni?

La promozione automatica del tipo si verifica nelle espressioni. Allo stesso tempo, i valori che appaiono nelle espressioni vengono automaticamente promossi a tipi con ampi intervalli di valori.

Quando la promozione automatica digita nelle espressioni:

• se uno degli operandi interi è di tipo int, allora tutti i valori di tipo byte, short e char vengono promossi al tipo int;
• se uno degli operandi interi è di tipo long, l'intera espressione viene promossa al tipo long;
• se uno degli operandi è di tipo float, allora anche il tipo dell'intera espressione sarà di tipo float (se non ci sono operandi di tipo double);
• se uno degli operandi è di tipo double, anche il tipo dell'intera espressione sarà double.

5. Un esempio di passaggio dal tipo byte a int in cui l'espressione non contiene operandi variabili di tipo int (long)

// byte -> int byte b; b = 1000/20; // b = 50, funziona perché il risultato è posto in byte

L'esempio sopra funziona correttamente perché:

• il risultato è posto (compatibile) nel tipo di byte;
• nessun operando di tipo int.

Nell'esempio sopra, 1000 supera l'intervallo di valori di byte. Innanzitutto, viene eseguito il cast del numero 1000 al tipo int. Ma il risultato

1000 / 20 = 50

viene convertito in byte di tipo e può adattarsi correttamente a una variabile B .

Se scrivi così:

byte b; b = 100.000 / 20; // errore, perché il risultato non si adatta al tipo di byte

quindi verrà emesso un errore di compilazione con l'output del messaggio:

In questo caso, il risultato non rientra nel tipo di byte:

100000 / 20 = 5000

Quindi questo numero (5000) diventa automaticamente di tipo int e il compilatore emetterà un messaggio di errore.

Se effettui un typecast esplicito:

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

quindi in questo caso il risultato 5000 di tipo int viene convertito in tipo byte. Come sai, una variabile di tipo int richiede 32 bit e una variabile di tipo byte richiede 8 bit. Il valore di una variabile di tipo int viene troncato. E abbiamo quello che abbiamo (b = -120).

Gli esempi precedenti si applicano anche alle variabili di tipo short e char.

6. Esempio. Avanzamento da byte a int, in cui l'espressione contiene un operando variabile int

// promozione dei tipi nelle espressioni // byte -> int byte b; int d; d = 20; // errore, il risultato è di tipo int, poiché la variabile d è di tipo int // b = 1000 / d;

Nell'esempio sopra, l'espressione usa la variabile D di tipo int. Pertanto, il compilatore darà un messaggio di errore:

Mancata corrispondenza del tipo: impossibile convertire da int a byte

Ciò significa che il risultato è di tipo int (non byte) anche se il valore rientra nell'intervallo di valori di tipo byte. Poiché l'espressione utilizza una variabile operando D di tipo int.

Se eseguiamo un casting esplicito di tipi, il risultato sarà corretto:

// promozione dei tipi nelle espressioni // byte -> int byte b; int d; d = 20; b = (byte) (1000 / d); // b = 50 - funziona correttamente

7. Esempio. Passando da int a long

Un esempio di promozione dei tipi da int a long. Se uno degli operandi è di tipo long, l'intera espressione viene promossa al tipo long.

int d; lunga l; d = 10000 * 200; // funziona, d = 2000000 // Errore! Mancata corrispondenza del tipo: impossibile convertire da long a int // d = 1L * 2L; - gli operandi 1L e 2L sono di tipo lungo l = 100; // errore, uno degli operandi è di tipo long // d = l * 2;

Come si può vedere dall'esempio, se uno degli operandi è di tipo long, allora l'intera espressione diventa di tipo long.

A volte ci sono situazioni in cui hai un valore di un certo tipo e devi assegnarlo a una variabile di un tipo diverso. Per alcuni tipi, questo può essere fatto senza conversione del tipo, in questi casi si parla di conversione automatica del tipo. In Java, la conversione automatica è possibile solo se la precisione della variabile di destinazione è sufficiente per memorizzare il valore originale. Tale conversione si verifica, ad esempio, quando una costante letterale o il valore di una variabile di tipo byte o short viene immessa in una variabile di tipo int. È chiamato estensione (allargando) o aumento (promozione), poiché un tipo con una profondità di bit inferiore viene espanso (ridimensionato) in un tipo compatibile più grande. La dimensione del tipo int è sempre sufficiente per memorizzare i numeri nell'intervallo consentito per il tipo byte, quindi, in tali situazioni, non è richiesto un operatore di cast esplicito. Il contrario non è vero nella maggior parte dei casi, quindi è necessario utilizzare l'operatore cast per eseguire il cast di un valore int in una variabile di byte. Questa procedura è talvolta chiamata restringimento (restringimento), perché stai dicendo esplicitamente al traduttore di convertire il valore per adattarlo a una variabile del tipo che desideri. Per eseguire il cast di un valore su un tipo specifico, è necessario specificare questo tipo, racchiuso tra parentesi, prima di esso. Il seguente frammento di codice mostra il casting da un'origine (variabile di tipo int) al tipo di destinazione (variabile di tipo byte). Se durante tale operazione il valore intero uscisse dall'intervallo consentito per il tipo di byte, verrebbe ridotto dividendo modulo per l'intervallo consentito per byte (il risultato della divisione modulo per un numero è il resto della divisione per questo numero) ,

int a = 100;
byteb = (byte) a;

2.2.1. Conversione automatica del tipo nelle espressioni

Quando si valuta il valore di un'espressione, la precisione richiesta per memorizzare i risultati intermedi spesso deve essere superiore a quella richiesta per rappresentare il risultato finale,

byte a = 40;
byte b = 50;
byte con = 100;
int d = a * b / s;

Il risultato dell'espressione intermedia (a * b) potrebbe andare al di fuori dell'intervallo di valori consentito per il tipo di byte. Questo è il motivo per cui Java promuove automaticamente ogni parte dell'espressione a int, quindi c'è spazio sufficiente per il risultato intermedio (a * b).

La conversione automatica del tipo a volte può causare messaggi di errore imprevisti del traduttore. Ad esempio, il codice mostrato di seguito, sebbene appaia abbastanza corretto, genera un messaggio di errore durante la fase di traduzione. In esso, stiamo cercando di scrivere il valore 50 * 2, che dovrebbe adattarsi perfettamente al tipo di byte, in una variabile di byte. Ma a causa della conversione automatica del tipo di risultato in int, riceviamo un messaggio di errore dal traduttore - dopo tutto, quando int viene inserito in byte, può verificarsi una perdita di precisione.

byte b = 50;
b = b * 2:
^ Tipo incompatibile per =. Cast esplicito necessario per convertire int in byte.
(Tipo incompatibile per =. Conversione esplicita richiestaint inbyte)

Testo corretto:
byteb = 50;
b = (byte) (b*2);

che fa sì che b inserisca il valore corretto di 100.

Se un'espressione utilizza variabili di tipo byte, short e int, il tipo dell'intera espressione viene automaticamente promosso a int per evitare l'overflow. Se il tipo di almeno una variabile nell'espressione è long, anche il tipo dell'intera espressione viene promosso a long. Ricorda che tutti i letterali interi che non terminano con una L (o 1) sono int.

Se l'espressione contiene operandi di tipo float, il tipo dell'intera espressione viene automaticamente promosso a float. Se almeno uno degli operandi è di tipo double, il tipo dell'intera espressione viene promosso a double. Per impostazione predefinita, Java tratta tutti i valori letterali in virgola mobile come doppi. Il programma seguente mostra come viene promosso il tipo di ogni valore nell'espressione in modo che corrisponda al secondo operando di ogni operatore binario.

classe promuovere (
public static void main (String args) (
byte b = 42;
carattere con= "un";
pantaloncini = 1024;
int i = 50000;
float f = 5.67f;
raddoppiato = 0,1234;
doppio risultato = (f * b) + (i / c) - (d * s);
Sistema, fuori. println ((f * b) + "+" + (i / c) + "-" + (d * s));
Sistema, fuori. println ("risultato =" + risultato); )
}

La sottoespressione f * b è un float moltiplicato per un byte, quindi viene automaticamente promosso a float. La seguente sottoespressione i / c (int diviso per char) viene promossa a int. Allo stesso modo, il tipo della sottoespressione d * s (doppio per breve) viene promosso a doppio. Nella fase successiva dei calcoli, ci occupiamo di tre risultati intermedi di tipo float, int e double. Innanzitutto, quando i primi due vengono sommati, il tipo int viene promosso a float e il risultato è un tipo float. Quando viene sottratto un valore double, il tipo di risultato viene promosso a double. Il risultato finale dell'intera espressione è un doppio.

Ora che abbiamo familiarità con tutti i tipi semplici, inclusi numeri interi e reali, simboli e variabili booleane, proviamo a mettere insieme tutte le informazioni. L'esempio seguente crea variabili di ciascuno dei tipi semplici e restituisce i valori di tali variabili.

classe SimpleTypes (
public static void main (String args) (
byte b = 0x55;
breve s = 0x55ff;
int i = 1000000;
lungo l = 0xffffffffL;
carattere con= 'A';
float f = .25f;
doppia d = .00001234;
booleano bool = vero;
System.out.println ("byte b =" + b);
System.out.println ("breve s =" + s);
System.out.println ("int i =" + i);
System.out.println ("long 1 =" + l);
System.out.println ("carattere con= ”+ S);
System.out.println ("float f =" + f);
System.out.println ("doppia d =" + d);
System.out.println ("boolean bool =" + bool);)
}

Eseguendo questo programma, dovresti ottenere il risultato mostrato di seguito:

byte b = 85
pantaloncini = 22015
int i = 1000000
lungo 1 = 4294967295
carattere con= a
flottante f = 0,25
doppia d = 1.234e-005
booleano bool = vero

Nota che gli interi vengono stampati in notazione decimale, sebbene abbiamo specificato i valori per alcuni di essi in notazione esadecimale.

Ultimo aggiornamento: 29/10/2018

Ciascun tipo di dati di base occupa un certo numero di byte di memoria. Ciò pone una restrizione alle operazioni che coinvolgono diversi tipi di dati. Considera il seguente esempio:

Int a = 4; byte b = a; //! Errore

In questo codice, incontreremo un errore. Sebbene sia byte che int rappresentino numeri interi. Inoltre, il valore della variabile a, che è assegnata a una variabile di tipo byte, rientra ampiamente nell'intervallo di valori per il tipo di byte (da -128 a 127). Tuttavia, ci imbattiamo in un errore in fase di compilazione. Perché in questo caso stiamo cercando di assegnare alcuni dati di 4 byte a una variabile di solo 1 byte.

Tuttavia, il tuo programma potrebbe dover eseguire questa conversione. In questo caso, devo utilizzare l'operazione di conversione del tipo (operazione ()):

Int a = 4; byte b = (byte) a; // conversione del tipo: da int a byte System.out.println (b); // 4

L'operazione di conversione del tipo implica un'indicazione tra parentesi del tipo in cui convertire il valore. Ad esempio, nel caso di un'operazione (byte), il tipo di dati int viene convertito nel tipo di byte. Di conseguenza, otteniamo un valore in byte.

Conversioni esplicite e implicite

Quando dati di tipo diverso sono coinvolti nella stessa operazione, non è sempre necessario utilizzare un'operazione di conversione del tipo. Alcuni tipi di conversioni vengono eseguiti implicitamente, automaticamente.

Conversioni automatiche

Le frecce nella figura mostrano quali conversioni di tipo possono essere eseguite automaticamente. Le frecce tratteggiate mostrano le conversioni automatiche con perdita di precisione.

Prodotto automaticamente senza alcun problema trasformazioni allarganti(allargamento) - espandono la rappresentazione di un oggetto in memoria. Ad esempio:

Byte b = 7; int d = b; // converte da byte a int

In questo caso, un byte, che occupa 1 byte in memoria, viene espanso in un int, che occupa 4 byte.

Le trasformazioni automatiche in espansione sono rappresentate dalle seguenti catene:

byte -> breve -> int -> lungo

int -> double

breve -> float -> double

char -> int

Conversioni automatiche con perdita di precisione

Alcune conversioni possono essere eseguite automaticamente tra tipi di dati con la stessa profondità di bit o anche da un tipo di dati con una profondità di bit maggiore a un tipo con una profondità di bit inferiore. Queste sono le seguenti catene di conversioni: int -> float, long -> float e long -> double vengono eseguite senza errori, ma potremmo riscontrare una perdita di informazioni durante la conversione.

Ad esempio:

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

Conversioni esplicite

Tutte le altre conversioni di tipo primitivo applicano in modo esplicito la definizione di conversione di tipo. Di solito, si tratta di restringere le conversioni da un tipo con una profondità di bit maggiore a un tipo con una profondità di bit inferiore:

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

Perdita di dati durante la conversione

Quando si utilizzano trasformazioni esplicite, potremmo riscontrare la perdita di dati. Ad esempio, con il seguente codice, non avremo problemi:

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

Il numero 5 si adatta bene all'intervallo di valori del tipo di byte, quindi dopo la conversione la variabile b sarà 5. Ma cosa succede nel caso seguente:

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

Il risultato è 2. In questo caso, 258 è fuori dall'intervallo per il byte (da -128 a 127), quindi il valore verrà troncato. Perché il risultato è esattamente il numero 2?

Il numero a, che è 258, in binario sarà 00000000 00000000 00000001 00000010. I valori dei byte occupano solo 8 bit in memoria. Pertanto, la rappresentazione binaria di int viene troncata alle 8 cifre giuste, ovvero 00000010, che fornisce 2 in decimale.

Troncare i numeri razionali a numeri interi

Quando si convertono valori in virgola mobile in valori interi, la parte frazionaria viene troncata:

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

Qui b sarebbe 56, anche se 57 sarebbe più vicino a 56,9898. Per evitare tali incidenti, è necessario utilizzare la funzione di arrotondamento, che si trova nella libreria matematica Java:

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

Trasformazioni nelle operazioni

Ci sono spesso situazioni in cui devi applicare varie operazioni, ad esempio addizione e prodotto, su valori di tipo diverso. Alcune regole si applicano anche qui:

se uno degli operandi dell'operazione è di tipo double, anche il secondo operando viene convertito nel tipo double

se la condizione precedente non è soddisfatta e uno degli operandi dell'operazione è di tipo float, anche il secondo operando viene convertito nel tipo float

se le condizioni precedenti non sono soddisfatte, uno degli operandi dell'operazione è di tipo long, quindi anche il secondo operando viene convertito in tipo long

in caso contrario, tutti gli operandi dell'operazione vengono convertiti nel tipo int

Esempi di trasformazioni:

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

Poiché l'operazione prevede un valore double, viene eseguito il cast dell'altro valore sul tipo double e la somma dei due valori a + b rappresenterà il tipo double.

Un altro esempio:

Byte a = 3; breve b = 4; byte c = (byte) (a + b);

Le due variabili sono di tipo byte e short (non double, float o long), quindi vengono convertite in int quando vengono aggiunte e la loro somma a + b rappresenta un int. Pertanto, se assegniamo questa somma a una variabile di tipo byte, dobbiamo nuovamente eseguire una conversione di tipo in byte.

Se le operazioni coinvolgono dati di tipo char, vengono convertite in int:

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