Il cast dei tipi nella pratica
Applichi il cast dei tipi in scenari reali, inclusi i calcoli numerici e le gerarchie OOP.
Il cast dei tipi nella pratica è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 4 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.
Casting dei tipi nella pratica
Il casting dei tipi viene utilizzato in tutto il codice Java reale: nei calcoli numerici, nelle gerarchie OOP, nelle collezioni generiche e nelle API legacy. Questa lezione illustra modelli pratici e possibili problemi.
Upcast: polimorfismo
Un upcast converte un sottotipo in un supertipo. È sempre sicuro e implicito: non è necessario alcun operatore di cast. Questo abilita il polimorfismo.
class Payment {}
class CreditCardPayment extends Payment {
public void authorizeCard() {}
}
CreditCardPayment cc = new CreditCardPayment();
Payment p = cc; // implicit upcast — always safe
// p.authorizeCard(); // Compile error — Payment doesn't have this method
// need downcast to access subclass methodsDowncast: accesso ai membri del sottotipo
Un downcast converte un riferimento a un supertipo nuovamente nel sottotipo originale. Richiede un cast esplicito e genera ClassCastException se l'oggetto non è effettivamente un'istanza di quel sottotipo.
Payment p = new CreditCardPayment();
// Downcast to access CreditCardPayment-specific method
if (p instanceof CreditCardPayment cc) {
cc.authorizeCard(); // safe with pattern matching
System.out.println("Card authorized");
}
// Unsafe downcast without check:
try {
BankTransfer bt = (BankTransfer) p; // ClassCastException!
} catch (ClassCastException e) {
System.out.println("Wrong type!");
}Casting numerico nei calcoli
La divisione tra interi tronca il risultato. Esegua il cast a double prima della divisione per ottenere un risultato preciso. Questo è uno degli errori aritmetici più comuni in Java.
int totalRevenue = 1000;
int months = 3;
// Integer division — truncates!
double wrong = totalRevenue / months;
System.out.println(wrong); // 333.0 (not 333.33)
// Correct: cast one operand to double first
double correct = (double) totalRevenue / months;
System.out.println(correct); // 333.3333333333333Casting nelle collezioni (prima dei generics)
Il codice legacy spesso memorizza gli oggetti in collezioni raw. Il downcast è necessario per recuperare valori tipizzati: verifichi sempre prima con instanceof.
import java.util.*;
// Legacy raw list (pre-Java 5 style)
List legacyList = new ArrayList();
legacyList.add("Alice");
legacyList.add(42);
for (Object item : legacyList) {
if (item instanceof String s) {
System.out.println("Name: " + s.toUpperCase());
} else if (item instanceof Integer n) {
System.out.println("Score: " + (n * 2));
}
}Casting con le interfacce
Un oggetto può essere convertito in qualsiasi interfaccia che implementa, permettendo di utilizzarlo nei contesti che richiedono quell'interfaccia.
interface Printable { void print(); }
interface Saveable { void save(); }
class Report implements Printable, Saveable {
public void print() { System.out.println("Printing report"); }
public void save() { System.out.println("Saving report"); }
}
Object obj = new Report();
if (obj instanceof Printable p) p.print();
if (obj instanceof Saveable s) s.save();Casting con gli array
I tipi array formano una gerarchia propria. Un String[] è un sottotipo di Object[]. Il casting degli array segue le stesse regole degli oggetti.
String[] names = {"Alice", "Bob"};
Object[] objs = names; // upcast — implicit
objs[0] = "Charlie"; // OK — still a String
try {
objs[0] = 42; // ArrayStoreException at runtime!
} catch (ArrayStoreException e) {
System.out.println("Cannot store Integer in String[]");
}
// Downcast back
String[] restored = (String[]) objs;E-commerce: instradamento dei pagamenti
Un esempio realistico: instradare la richiesta al processore di pagamento corretto in base al tipo effettivo del pagamento.
interface Payment { double amount(); }
record CreditCard(String last4, double amount) implements Payment {}
record CryptoPayment(String wallet, double amount) implements Payment {}
record BankWire(String iban, double amount) implements Payment {}
static void process(Payment p) {
switch (p) {
case CreditCard cc -> System.out.println("Charging card *" + cc.last4());
case CryptoPayment cp -> System.out.println("Sending to wallet " + cp.wallet());
case BankWire bw -> System.out.println("Wiring to IBAN " + bw.iban());
}
}
process(new CreditCard("4242", 99.99));
process(new CryptoPayment("0xABCD", 0.05));Casting a Number per la matematica generica
La superclasse Number permette di eseguire operazioni numeriche generiche su qualsiasi tipo numerico effettuando l'upcast a Number e chiamando doubleValue().
import java.util.List;
List<Number> numbers = List.of(1, 2.5, 3L, 4.0f);
double sum = 0;
for (Number n : numbers) {
sum += n.doubleValue(); // works for int, double, long, float
}
System.out.printf("Sum: %.1f%n", sum); // 10.5Metodo di utilità per il casting sicuro
Un metodo di utilità riutilizzabile che restituisce un Optional vuoto invece di generare un'eccezione in caso di cast non valido: ideale per il codice strutturato come una pipeline.
import java.util.Optional;
public static <T> Optional<T> safeCast(Object obj, Class<T> clazz) {
return clazz.isInstance(obj)
? Optional.of(clazz.cast(obj))
: Optional.empty();
}
// Usage
Object val = "hello";
safeCast(val, String.class)
.ifPresent(s -> System.out.println(s.toUpperCase())); // HELLO
safeCast(val, Integer.class)
.ifPresentOrElse(
n -> System.out.println(n),
() -> System.out.println("Not an Integer") // prints this
);Errori comuni da evitare
Presti attenzione ai seguenti errori comuni nel casting:
- Dimenticare il cast prima della divisione:
int/intrestituisce sempre un intero - Eseguire un downcast senza verificare con instanceof → ClassCastException
- Confondere l'upcasting, sicuro, con il downcasting, rischioso
- Confondere il casting dei tipi wrapper:
(int) longValrispetto alongVal.intValue()
// Mistake 1: integer division
double avg = 7 / 2; // 3.0 — WRONG
double fixed = 7.0 / 2; // 3.5 — correct
// Mistake 2: unwrapping Long as int
Long bigId = 1234567890123L;
// int id = (int) bigId; // compiles but truncates!
long id = bigId; // correct
System.out.println(avg); // 3.0
System.out.println(fixed); // 3.5
System.out.println(id); // 1234567890123Verifica rapida
Qual è l'output di questo codice?
int a = 7; int b = 2; double result = (double) a / b; System.out.println(result);
Riepilogo: casting dei tipi nella pratica
Punti chiave:
- L'upcast (sottotipo → supertipo) è implicito e sempre sicuro
- Il downcast (supertipo → sottotipo) richiede un cast esplicito; utilizzi prima instanceof
- Il pattern matching con instanceof combina verifica e cast in un'unica espressione
- Esegua il cast del numeratore a double prima della divisione per evitare il troncamento degli interi
- Utilizzi il pattern matching con switch per un dispatch chiaro basato sul tipo
- Costruisca utility safeCast per utilizzare Optional invece delle eccezioni
Domande Frequenti
La lezione «Il cast dei tipi nella pratica» è gratuita?
Sì — il testo completo di «Il cast dei tipi nella pratica» è 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 «Il cast dei tipi nella pratica»?
Applichi il cast dei tipi in scenari reali, inclusi i calcoli numerici e le gerarchie OOP. 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 4 di 4.
Quanto tempo richiede la lezione «Il cast dei tipi nella pratica»?
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
- Tipi primitivi e tipi di riferimento
- Conversioni con ampliamento e restringimento
- L'operatore instanceof
- Il cast dei tipi nella pratica