0Pricing
Java Academy · Lezione

Conversioni con ampliamento e restringimento

Apprenda le conversioni automatiche con ampliamento e come eseguire in sicurezza i cast espliciti con restringimento.

Conversioni con ampliamento e restringimento è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.

Conversioni di tipo in Java

Java permette di convertire i valori tra tipi compatibili. Le direzioni sono due:

  • Widening — conversione a un tipo più grande (sicura, automatica)
  • Narrowing — conversione a un tipo più piccolo (rischiosa, richiede un cast esplicito)

Conversione widening

Il widening avviene automaticamente quando si assegna un valore a un tipo compatibile più grande. Non si perde alcun dato, perché il tipo di destinazione può rappresentare tutti i valori del tipo di origine.

Ordine del widening: byte → short → int → long → float → double

byte b = 42;
short s = b;    // byte → short (widening)
int i = s;      // short → int (widening)
long l = i;     // int → long (widening)
float f = l;    // long → float (widening)
double d = f;   // float → double (widening)

System.out.println(d); // 42.0

Conversione narrowing

Il narrowing deve essere eseguito esplicitamente con l'operatore di cast (type). Il valore può essere troncato o alterato se non rientra nel tipo di destinazione.

double price = 99.99;
int wholePart = (int) price; // narrows — decimal truncated
System.out.println(wholePart); // 99 (not rounded!)

long bigNum = 130L;
byte small = (byte) bigNum;  // 130 overflows byte (max 127)
System.out.println(small);   // -126 (unexpected!)

Overflow durante il narrowing

Quando si verifica un overflow durante il narrowing, Java riporta il valore all'interno dell'intervallo utilizzando l'aritmetica modulare, senza generare eccezioni. È necessario gestire manualmente questa situazione.

int million = 1_000_000;
byte narrowed = (byte) million;
System.out.println(narrowed); // 64 (wraps around)

// Safe narrowing: check bounds first
if (million >= Byte.MIN_VALUE && million <= Byte.MAX_VALUE) {
    byte safe = (byte) million;
} else {
    System.out.println("Value doesn't fit in byte!");
}

Conversioni tra char e int

char è un intero senza segno a 16 bit che rappresenta un punto di codice Unicode. Viene convertito automaticamente in int, ma la conversione da int a char richiede un cast esplicito.

char letter = 'A';
int code = letter;          // widening: char → int
System.out.println(code);   // 65

int nextCode = code + 1;
char nextLetter = (char) nextCode; // narrowing: int → char
System.out.println(nextLetter);    // B

// Useful for Caesar cipher shifts
char shifted = (char) ('a' + 3);
System.out.println(shifted); // d

Troncamento da virgola mobile a intero

Il cast di un numero a virgola mobile a un intero tronca verso zero: non esegue un arrotondamento. Utilizzare Math.round() se è necessario arrotondare.

double pos = 3.9;
double neg = -3.9;

System.out.println((int) pos);         // 3 (not 4)
System.out.println((int) neg);         // -3 (not -4)
System.out.println(Math.round(pos));   // 4
System.out.println(Math.round(neg));   // -4

Conversioni da String a numero

Il parsing di una String in un numero si esegue tramite i metodi delle classi wrapper, non tramite casting. Passare una stringa non numerica genera NumberFormatException.

String input = "42";
int parsed = Integer.parseInt(input);
double parsedD = Double.parseDouble("3.14");

System.out.println(parsed + 1);  // 43
System.out.println(parsedD);     // 3.14

try {
    int bad = Integer.parseInt("abc");
} catch (NumberFormatException e) {
    System.out.println("Not a valid number!");
}

Conversioni da numero a String

È possibile convertire un numero in una String con String.valueOf(), Integer.toString() oppure concatenando la stringa "".

int score = 95;
String s1 = String.valueOf(score);    // "95"
String s2 = Integer.toString(score);  // "95"
String s3 = score + "";              // "95" (concat trick)

System.out.println(s1.getClass().getSimpleName()); // String

// Converting to different bases
System.out.println(Integer.toBinaryString(42)); // 101010
System.out.println(Integer.toHexString(255));   // ff

Promozione nelle espressioni

Nelle espressioni aritmetiche, Java promuove automaticamente gli operandi:

  • byte, short, char → vengono promossi a int prima dell'operazione
  • Se uno dei due operandi è long, il risultato è long
  • Se uno dei due è float o double, il risultato corrisponde al tipo più ampio
byte x = 10;
byte y = 20;
// byte z = x + y; // compile error! sum is promoted to int
int z = x + y;      // correct

long a = 100L;
float b = 2.5f;
double result = a * b; // long * float → double
System.out.println(result); // 250.0

Operatori di assegnazione composta

Gli operatori composti come +=, -=, *= includono un cast implicito a un tipo più ristretto. Questo permette di scrivere codice conciso con variabili byte e short.

byte count = 100;
// count = count + 1; // compile error — int result needs cast
count += 1;           // OK — compound op casts automatically
System.out.println(count); // 101

short total = 1000;
total *= 2;  // implicit narrow cast included
System.out.println(total); // 2000

Pratica: parsing sicuro degli interi

Un modello realistico consiste nel analizzare in modo sicuro l'input dell'utente, verificarne l'intervallo e convertirlo al tipo esatto necessario.

public static byte parseAsByte(String input) {
    int value = Integer.parseInt(input); // can throw NumberFormatException
    if (value < Byte.MIN_VALUE || value > Byte.MAX_VALUE) {
        throw new IllegalArgumentException(
            "Value " + value + " out of byte range");
    }
    return (byte) value;
}

// Usage
System.out.println(parseAsByte("100")); // 100
System.out.println(parseAsByte("200")); // IllegalArgumentException

Verifica rapida

Qual è l'output del codice seguente?

double d = -7.8;
int i = (int) d;
System.out.println(i);

Riepilogo: widening e narrowing

Punti chiave:

  • Il widening è automatico e sicuro: byte→short→int→long→float→double
  • Il narrowing richiede un cast esplicito e può causare perdita di dati o overflow
  • char viene ampliato a int; int può essere ristretto nuovamente a char con un cast
  • La conversione da virgola mobile a int tronca verso zero, non arrotonda
  • Utilizzi Integer.parseInt/Double.parseDouble per convertire le String in numeri
  • Gli operatori composti (+=, *=) includono cast impliciti a un tipo più ristretto

Domande Frequenti

La lezione «Conversioni con ampliamento e restringimento» è gratuita?

Sì — il testo completo di «Conversioni con ampliamento e restringimento» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.

Cosa imparerò in «Conversioni con ampliamento e restringimento»?

Apprenda le conversioni automatiche con ampliamento e come eseguire in sicurezza i cast espliciti con restringimento. Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Conversioni con ampliamento e restringimento»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Tipi primitivi e tipi di riferimento
  2. Conversioni con ampliamento e restringimento
  3. L'operatore instanceof
  4. Il cast dei tipi nella pratica
← Torna a Java Academy