L'operatore instanceof
Utilizzi instanceof per verificare i tipi degli oggetti prima del cast ed evitare ClassCastException.
L'operatore instanceof è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 3 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.
L'operatore instanceof
L'operatore instanceof verifica durante l'esecuzione se un oggetto è un'istanza di un determinato tipo. Restituisce true o false e previene ClassCastException prima del casting.
Utilizzo di base di instanceof
Utilizzi instanceof per verificare il tipo effettivo di un oggetto prima di eseguire un cast sicuro.
Object obj = "Hello, Java!";
if (obj instanceof String) {
String s = (String) obj;
System.out.println(s.toUpperCase()); // HELLO, JAVA!
}
Object num = Integer.valueOf(42);
System.out.println(num instanceof Integer); // true
System.out.println(num instanceof String); // falseinstanceof con l'ereditarietà
instanceof restituisce true se l'oggetto è un'istanza della classe o di una qualsiasi sottoclasse (o di una qualsiasi interfaccia implementata).
class Animal {}
class Dog extends Animal {}
class Cat extends Animal {}
Animal a = new Dog();
System.out.println(a instanceof Animal); // true
System.out.println(a instanceof Dog); // true
System.out.println(a instanceof Cat); // falsePattern matching con instanceof (Java 16+)
Java 16 ha introdotto il pattern matching per instanceof: è possibile dichiarare una variabile di associazione nella stessa espressione, eliminando il cast esplicito.
Object shape = "circle";
// Old way
if (shape instanceof String) {
String s = (String) shape;
System.out.println(s.length());
}
// New way (Java 16+) — binding variable 's' is in scope
if (shape instanceof String s) {
System.out.println(s.length()); // 6
}Pattern matching in un metodo
Il pattern matching rende il dispatch basato sul tipo chiaro e sicuro. La variabile di associazione è visibile solo nel contesto in cui si sa che la condizione è vera.
sealed interface Shape permits Circle, Rectangle {}
record Circle(double radius) implements Shape {}
record Rectangle(double width, double height) implements Shape {}
static double area(Shape s) {
if (s instanceof Circle c) {
return Math.PI * c.radius() * c.radius();
} else if (s instanceof Rectangle r) {
return r.width() * r.height();
}
throw new IllegalArgumentException("Unknown shape");
}
System.out.println(area(new Circle(5))); // 78.53...
System.out.println(area(new Rectangle(4, 6))); // 24.0instanceof con null
null instanceof AnyType restituisce sempre false e non genera mai eccezioni. Questo rende instanceof un modo sicuro rispetto a null per verificare un oggetto prima del casting.
String s = null;
System.out.println(s instanceof String); // false (not NPE)
Object o = null;
if (o instanceof Number n) {
System.out.println(n.intValue());
} else {
System.out.println("Not a number (or null)"); // prints this
}Espressioni switch e pattern matching
Java 21 estende il pattern matching alle espressioni switch, consentendo un instradamento basato sul tipo senza ricorrere a catene di if-else.
static String describe(Object obj) {
return switch (obj) {
case Integer i -> "Integer: " + i;
case Double d -> "Double: " + d;
case String s -> "String of length " + s.length();
case null -> "null value";
default -> "Unknown: " + obj.getClass().getSimpleName();
};
}
System.out.println(describe(42)); // Integer: 42
System.out.println(describe(3.14)); // Double: 3.14
System.out.println(describe("hello")); // String of length 5
System.out.println(describe(null)); // null valueClassCastException senza instanceof
Eseguire il casting senza una verifica preliminare causa ClassCastException durante l'esecuzione: un errore comune nel codice legacy che il pattern matching aiuta a prevenire.
Object obj = "I am a String";
try {
Integer i = (Integer) obj; // ClassCastException!
} catch (ClassCastException e) {
System.out.println("Cannot cast String to Integer");
}
// Safe version
if (obj instanceof Integer i) {
System.out.println("Is integer: " + i);
} else {
System.out.println("Not an integer");
}Pratica: elaborazione di una lista eterogenea
Un caso d'uso realistico consiste nell'elaborare una lista eterogenea di oggetti tramite il pattern matching.
import java.util.List;
List<Object> events = List.of(
"User login", 42, 3.14, "Payment processed", 100
);
double numericSum = 0;
for (Object e : events) {
if (e instanceof Integer n) numericSum += n;
else if (e instanceof Double d) numericSum += d;
else if (e instanceof String s) System.out.println("Log: " + s);
}
System.out.printf("Numeric sum: %.2f%n", numericSum); // 145.14Classi sealed e verifica esaustiva
Le classi sealed (Java 17+) limitano le classi che possono estenderle. In combinazione con il pattern matching switch, permettono al compilatore di verificare che tutti i casi siano gestiti: non è necessario alcun caso default.
sealed interface Notification permits EmailNotification, SmsNotification {}
record EmailNotification(String to, String body) implements Notification {}
record SmsNotification(String phone, String text) implements Notification {}
static void send(Notification n) {
switch (n) {
case EmailNotification e ->
System.out.println("Email to " + e.to() + ": " + e.body());
case SmsNotification s ->
System.out.println("SMS to " + s.phone() + ": " + s.text());
// no default needed — compiler knows all cases are covered
}
}Pattern con guardia
Il pattern matching supporta le guardie con when (Java 21), per aggiungere condizioni booleane ai controlli sul tipo.
static String classify(Number n) {
return switch (n) {
case Integer i when i < 0 -> "negative int: " + i;
case Integer i when i == 0 -> "zero";
case Integer i -> "positive int: " + i;
case Double d -> "double: " + d;
default -> "other number";
};
}
System.out.println(classify(-5)); // negative int: -5
System.out.println(classify(0)); // zero
System.out.println(classify(7)); // positive int: 7Verifica rapida
Che cosa restituisce l'espressione seguente?
Object obj = null; boolean result = obj instanceof String; System.out.println(result);
Riepilogo: operatore instanceof
Punti chiave:
- instanceof verifica il tipo durante l'esecuzione e previene ClassCastException
- Restituisce false per null e non genera mai NPE
- Restituisce true per la classe stessa e per tutte le sue sottoclassi e interfacce
- Pattern matching di Java 16+: if (x instanceof String s) combina verifica e cast
- Lo switch di Java 21 con i pattern instrada in modo chiaro in base al tipo, con guardie opzionali
- Le classi sealed e lo switch esaustivo eliminano la necessità di un caso default
Domande Frequenti
La lezione «L'operatore instanceof» è gratuita?
Sì — il testo completo di «L'operatore instanceof» è 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 «L'operatore instanceof»?
Utilizzi instanceof per verificare i tipi degli oggetti prima del cast ed evitare ClassCastException. 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 3 di 4.
Quanto tempo richiede la lezione «L'operatore instanceof»?
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