1. Conversione di tipo implicita (automatica)
In Java (come in altri linguaggi) le variabili hanno un tipo rigoroso — se una variabile è dichiarata come int, può contenere solo numeri interi, e se è double — solo numeri a virgola mobile. Ma nei programmi reali spesso capita di dover “spostare” un valore da una variabile a un’altra di tipo diverso. Per esempio:
- Otteniamo da un metodo un int, ma vogliamo usarlo come double per calcoli con frazioni.
- Memorizziamo il codice di un simbolo come numero (int), ma vogliamo ottenere il simbolo stesso (char).
- Abbiamo il risultato dei calcoli in double, ma ci serve un risultato intero (int), ad esempio per stampare il numero di mele intere.
In Java esistono due modi principali di conversione di tipo: implicita (automatica) ed esplicita (manuale).
Che cos’è?
La conversione implicita è quando Java converte da sola, “senza il tuo intervento”, un valore da un tipo a un altro, se ciò è sicuro e non comporta perdita di dati.
Questo accade quando assegni un valore di tipo più piccolo a una variabile di tipo più grande. Per esempio, da int a double, da char a int, da float a double.
Analogia: immagina di avere un bicchiere d’acqua (int) e un secchio (double). Se versi l’acqua dal bicchiere al secchio — non si rovescia nulla, ci sta tutto. In questi casi Java consente la conversione automatica.
Esempio: int → double
int apples = 5;
double applesWeight = apples; // int diventa automaticamente double
System.out.println(applesWeight); // 5.0
Esempio: char → int
Ogni simbolo in Java è semplicemente un numero della tabella Unicode. Pertanto, la conversione da char a int avviene automaticamente:
char letter = 'A';
int code = letter; // 'A' diventa 65 (codice del carattere in Unicode)
System.out.println(code); // 65
Tabella delle conversioni implicite
| Origine | Destinazione (implicita) |
|---|---|
|
|
|
|
|
|
|
|
|
|
|
|
Importante: la conversione implicita funziona solo nella direzione dell’allargamento (da un tipo più piccolo a uno più grande).
2. Conversione di tipo esplicita (manuale) (type casting)
Il cast esplicito è necessario quando vuoi convertire un valore da un tipo più grande a uno più piccolo o tra tipi non compatibili. In questo caso Java richiede che tu indichi esplicitamente di essere consapevole della possibile perdita di dati.
Analogia: stai cercando di versare l’acqua da un secchio (double) in un bicchiere (int) — una parte dell’acqua può traboccare e Java richiede che tu dica: “Sì, capisco che una parte dei dati può andare persa!”
Sintassi
tip_naznacheniya peremennaya = (tip_naznacheniya) vyrazhenie;
Esempio: double → int
double price = 12.99;
int roundedPrice = (int) price; // la parte frazionaria viene semplicemente scartata!
System.out.println(roundedPrice); // 12
Attenzione: non avviene alcun arrotondamento! Si “taglia” tutto ciò che segue il punto. Per arrotondare usa Math.round().
Esempio: int → char
int code = 66;
char letter = (char) code; // 66 è il carattere 'B'
System.out.println(letter); // B
Esempio: double → float
double d = 3.1415926535;
float f = (float) d; // si perde parte della precisione
System.out.println(f); // 3.1415927 (meno cifre dopo la virgola)
3. Conversione tra numeri e caratteri (char e numeri)
Perché è possibile?
In Java i caratteri (char) in realtà sono solo numeri della tabella Unicode. Per questo possono essere convertiti liberamente in int e viceversa.
Esempio: char → int
char ch = '\u0416';
int code = ch;
System.out.println(code); // 1046
Esempio: int → char
int code = 8364;
char symbol = (char) code;
System.out.println(symbol); // €
Pratica: stampiamo l’alfabeto
for (int i = 65; i < 65 + 26; i++) {
System.out.print((char) i + " ");
}
// Stamperà: A B C D ... Z
4. Conversione tra interi e numeri a virgola mobile
int → double (implicita)
int count = 10;
double avg = count; // allargamento implicito
System.out.println(avg); // 10.0
double → int (esplicita)
double score = 8.75;
int rounded = (int) score;
System.out.println(rounded); // 8
Come arrotondare secondo le regole della matematica?
Se hai bisogno non solo di “tagliare” la parte frazionaria, ma di arrotondare all’intero più vicino, usa Math.round():
double price = 8.75;
int rounded = (int) Math.round(price);
System.out.println(rounded); // 9
5. Cosa succede con il “restringimento” del tipo? Perdita di dati
Esempio: int → byte
int big = 300;
byte small = (byte) big;
System.out.println(small); // 44 (!)
Perché 44? Perché byte memorizza valori da -128 a 127 e, se il numero non rientra nel range, avviene un “taglio” modulo 256 (resto della divisione).
Esempio: double → int
double d = 1e20;
int i = (int) d;
System.out.println(i); // -2147483648 (valore minimo di int)
Il numero grande non rientra nel range di int e il risultato diventa “strano”.
6. Conversione durante i calcoli: tipi “misti”
Esempio: int + double
int a = 3;
double b = 2.5;
double result = a + b; // int diventa automaticamente double
System.out.println(result); // 5.5
Esempio: char + int
char ch = 'A'; // 65
int offset = 2;
char next = (char) (ch + offset); // char diventa automaticamente int
System.out.println(next); // C
7. Conversione tra numeri e stringhe
Sebbene non sia propriamente un “cast”, spesso serve convertire un numero in stringa e viceversa.
int → String
int x = 123;
String s = Integer.toString(x);
// oppure semplicemente: String s = "" + x;
String → int
String s = "456";
int x = Integer.parseInt(s);
8. Errori tipici e sfumature
Errore n. 1: Perdita della parte frazionaria con double → int. Molto spesso i principianti pensano che (int) 3.99 dia 4. In realtà il risultato è 3, la parte frazionaria viene semplicemente scartata. Per un arrotondamento corretto usa Math.round().
Errore n. 2: Il “restringimento” implicito non funziona. Non puoi semplicemente scrivere int x = 300; byte b = x — il compilatore genererà un errore. Devi indicare esplicitamente (byte) x, ma preparati a risultati strani se il numero supera il range di byte.
Errore n. 3: Conversione tra tipi incompatibili. Non puoi scrivere (int) "123" — la stringa va convertita in numero tramite Integer.parseInt().
Errore n. 4: Problemi con char e int. La conversione da int a char funziona solo per valori che esistono realmente in Unicode. Se passi un numero grande, il risultato sarà un simbolo inatteso.
Errore n. 5: Tipi misti nelle espressioni. Se un’espressione contiene int e double, il risultato sarà sempre double. Questo può influire in modo inatteso sulla logica del programma, se ti aspetti un numero intero.
Errore n. 6: L’arrotondamento non è un cast! (int) x non arrotonda, ma scarta semplicemente la parte frazionaria. Per arrotondare usa Math.round().
GO TO FULL VERSION