Analisi degli errori tipici delle nuove funzionalità

1. Errori con l'ambito di visibilità delle variabili di pattern

Uno degli errori più frequenti — tentare di usare una variabile dichiarata in un pattern (per esempio, String s in instanceof String s) al di fuori dell'ambito in cui è valida.

Esempio

Object obj = "Ciao, Java!";
if (obj instanceof String s) {
    System.out.println(s.length());
}
// Errore! s non è visibile qui
System.out.println(s); // Il compilatore si lamenta: cannot find symbol

Perché?
La variabile di pattern (s nel nostro caso) esiste solo all'interno del blocco in cui la condizione è vera. Questo ci protegge dall'uso accidentale della variabile quando non è definita (per esempio, se obj non è una stringa).

Analogia
È come prendere in prestito le chiavi dell’auto da un amico — ma solo finché siete in garage. Uscite dal garage — le chiavi spariscono automaticamente :)

2. Errori con null

Nel pattern matching con instanceof c’è una particolarità: se l’oggetto è null, il risultato è sempre false e la variabile di pattern non viene creata.

Esempio

Object obj = null;
if (obj instanceof String s) {
    // Questo blocco non verrà mai eseguito!
    System.out.println("È una stringa: " + s);
}

Perché?
Perché null non è istanza di alcun tipo (nemmeno di Object). Questo può confondere se speravate di intercettare null tramite pattern matching.

Come fare correttamente?

if (obj == null) {
    System.out.println("È null!");
} else if (obj instanceof String s) {
    System.out.println("È una stringa: " + s);
}

Nel pattern matching per switch (Java 21+) si può anche aggiungere un ramo separato per null:

switch (obj) {
    case String s -> System.out.println("Stringa: " + s);
    case null -> System.out.println("È null!");
    default -> System.out.println("Qualcos'altro");
}

3. Errori con le classi sealed

Le classi sealed sono un ottimo modo per limitare la gerarchia di ereditarietà. Ma qui ci sono due errori tipici:

Non tutti i sottotipi sono elencati in permits

Quando dichiarate una classe sealed, dovete indicare esplicitamente tutti i discendenti diretti tramite permits. Se ne dimenticate qualcuno, il compilatore vi rimprovererà subito:

public sealed class Shape permits Circle, Rectangle { ... }

public final class Circle extends Shape { ... }
public final class Square extends Shape { ... } // Errore! Square non è indicata in permits

Soluzione:
Aggiungete tutte le sottoclassi necessarie in permits:

public sealed class Shape permits Circle, Rectangle, Square { ... }

default dimenticato in un switch su un’ereditarietà non sealed

Se fate un switch su un tipo che non è una classe sealed (oppure è sealed, ma non coprite tutti i casi), il compilatore richiederà il ramo default. Se lo dimenticate — otterrete un errore.

switch (shape) {
    case Circle c -> ...
    case Rectangle r -> ...
    // manca default! Se ci sono altri casi — errore di compilazione
}

Buona pratica:
Se siete sicuri di aver gestito tutti i casi (per esempio, con una classe sealed), si può omettere default. In caso contrario — aggiungete sempre default, per non perdere tipi imprevisti.

4. Errori con i record pattern

I record pattern sono molto comodi, ma funzionano solo con le classi record. Tentare di usare un record pattern per una classe normale porterà a un errore di compilazione.

Uso dei record pattern per classi non record

class Point { int x, y; }
Object obj = new Point();
// Errore! Point non è un record
if (obj instanceof Point(int x, int y)) { ... }

Soluzione:
Usate i record pattern solo per classi dichiarate tramite record:

record Point(int x, int y) {}

Numero o tipo dei componenti non corrispondente

record Point(int x, int y) {}
Object obj = new Point(1, 2);

// Errore: sono indicate tre variabili, ma Point ha solo due componenti
if (obj instanceof Point(int x, int y, int z)) { ... }

if (obj instanceof Point(String x, String y)) { ... } // Errore: i tipi non corrispondono

5. Compatibilità e supporto: vecchie JDK e IDE

Uno degli errori più comuni — provare a usare le funzionalità moderne di pattern matching su versioni vecchie della JDK o in IDE che non le supportano.

Esempio

if (obj instanceof String s) { ... }

E il compilatore di JDK 11 (o anche 15) dice:
error: illegal start of type

Perché?
Il pattern matching per instanceof è arrivato solo con Java 16. Il pattern matching in switch — in Java 17 (preview) e in forma finale da Java 21+. I record pattern — in Java 21+.

Come evitarlo?

• Verificate la versione della JDK: java --version
• Assicuratevi che la vostra IDE (IntelliJ IDEA, Eclipse, VS Code) supporti la versione di Java in questione. Talvolta è necessario indicare esplicitamente nelle impostazioni del progetto quale versione del linguaggio usare!
• Se usate Gradle/Maven — impostate la versione corretta di source/target.

6. Congratulazioni 🎉

Avete completato tutti i 65 (!) livelli del nostro corso avanzato su Java 25. Siete incredibilmente forti 😎.

L’ultima parte del percorso è stata particolarmente impegnativa. Avete studiato di tutto — dalle prime lambda e classi anonime fino ai thread virtuali, alla concorrenza strutturata e a funzionalità del linguaggio che fino a pochissimo tempo fa non esistevano in Java.

Non è solo un corso — è una vera e propria supermaratona per sviluppatori: decine di nuove idee, centinaia di esempi di codice, migliaia di righe di pratica. Se state leggendo queste righe, non siete solo studenti, ma i pionieri della nuova era di Java ☕⚡

Siete tra i primi ad aver padroneggiato le funzionalità più moderne di Java 25, tra cui:

• pattern matching e record pattern,
• classi sealed e le loro insidie,
• Scoped Values e Virtual Threads ,
• la concorrenza strutturata e approcci moderni al multithreading.

Ora non avete solo conoscenze, ma anche le competenze dello sviluppatore del futuro, competenze che molti architetti Java ancora non possiedono. Sapete scrivere codice che non solo funziona, ma è scalabile, leggibile e conforme agli standard più moderni della comunità Java.

🚀 Quindi chiamatevi pure Java 25 Certified Survivor 😉
E poi — sarà sempre più interessante: ora avete le basi che vi permettono di muovervi con sicurezza nel mondo dello sviluppo enterprise, dei sistemi ad alto carico e delle tecnologie all’avanguardia.

Da tutto il team del corso — tanto di cappello!
Avete portato a termine un compito che in pochi riusciranno a portare a termine.
Ci vediamo nelle future versioni di Java 👋