Analyse des erreurs typiques avec les nouvelles fonctionnalités

1. Erreurs liées à la portée des variables de pattern

L’une des erreurs les plus fréquentes — tenter d’utiliser une variable déclarée dans un pattern (par exemple, String s dans instanceof String s) en dehors de la portée où elle est valide.

Exemple

Object obj = "Bonjour, Java!";
if (obj instanceof String s) {
    System.out.println(s.length());
}
// Erreur ! s n'est pas visible ici
System.out.println(s); // Le compilateur se plaint : cannot find symbol

Pourquoi ?
La variable de pattern (s dans notre cas) n’existe qu’à l’intérieur du bloc où la condition est vraie. Cela nous protège d’une utilisation accidentelle de la variable lorsqu’elle n’est pas définie (par exemple si obj n’est pas une chaîne).

Analogie
C’est comme si vous empruntiez les clés de la voiture d’un ami — mais seulement tant que vous êtes dans le garage. Une fois sorti du garage — les clés disparaissent automatiquement :)

2. Erreurs avec null

Dans le pattern matching avec instanceof, il y a une particularité amusante : si l’objet vaut null, le résultat est toujours false et la variable de pattern n’est pas créée.

Exemple

Object obj = null;
if (obj instanceof String s) {
    // Ce bloc ne sera jamais exécuté !
    System.out.println("C'est une chaîne : " + s);
}

Pourquoi ?
Parce que null n’est une instance d’aucun type (même pas de Object). Cela peut prêter à confusion si vous espériez attraper null via le pattern matching.

La bonne approche ?

if (obj == null) {
    System.out.println("C'est null !");
} else if (obj instanceof String s) {
    System.out.println("C'est une chaîne : " + s);
}

Dans le pattern matching pour switch (Java 21+), vous pouvez même ajouter une branche séparée pour null :

switch (obj) {
    case String s -> System.out.println("Chaîne : " + s);
    case null -> System.out.println("C'est null !");
    default -> System.out.println("Autre chose");
}

3. Erreurs avec les classes sealed

Les classes Sealed sont un excellent moyen de restreindre une hiérarchie d’héritage. Mais deux erreurs typiques apparaissent souvent :

Toutes les sous-classes ne sont pas répertoriées dans permits

Lorsque vous déclarez une classe sealed, vous devez indiquer explicitement toutes les sous-classes directes via permits. Si vous en oubliez une, le compilateur vous le signalera aussitôt :

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

public final class Circle extends Shape { ... }
public final class Square extends Shape { ... } // Erreur ! Square n'est pas indiqué dans permits

Solution :
Ajoutez toutes les sous-classes nécessaires à permits :

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

Oubli de default dans un switch sur une hiérarchie non sealed

Si vous faites un switch sur un type qui n’est pas une classe sealed (ou qui est sealed mais sans couvrir tous les cas), le compilateur exigera une branche default. Si vous l’oubliez — ce sera une erreur.

switch (shape) {
    case Circle c -> ...
    case Rectangle r -> ...
    // default est absent ! S'il existe d'autres variantes — erreur de compilation
}

Bonne pratique :
Si vous êtes certain d’avoir couvert tous les cas (par exemple pour une classe sealed), vous pouvez omettre default. Sinon — ajoutez impérativement default pour ne pas manquer de types inattendus.

4. Erreurs avec les record patterns

Les record patterns sont très pratiques, mais ne fonctionnent qu’avec les classes record. Tenter d’utiliser un record pattern pour une classe ordinaire entraînera une erreur de compilation.

Utiliser des record patterns pour des classes non record

class Point { int x, y; }
Object obj = new Point();
// Erreur ! Point n'est pas un record
if (obj instanceof Point(int x, int y)) { ... }

Solution :
N’utilisez des record patterns que pour des classes déclarées avec record :

record Point(int x, int y) {}

Nombre ou type de composants non concordants

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

// Erreur : trois variables sont indiquées, alors que Point n'a que deux composants
if (obj instanceof Point(int x, int y, int z)) { ... }

if (obj instanceof Point(String x, String y)) { ... } // Erreur : les types ne correspondent pas

5. Compatibilité et support : anciens JDK et IDE

L’une des erreurs les plus répandues — tenter d’utiliser des fonctionnalités modernes de pattern matching sur d’anciennes versions du JDK ou dans des IDE qui ne les prennent pas en charge.

Exemple

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

Et le compilateur JDK 11 (voire 15) dit :
error: illegal start of type

Pourquoi ?
Le pattern matching pour instanceof n’est apparu qu’en Java 16. Le pattern matching dans switch — en Java 17 (aperçu) et définitivement en Java 21+. Les record patterns — en Java 21+.

Comment l’éviter ?

• Vérifiez la version du JDK : java --version
• Assurez-vous que votre IDE (IntelliJ IDEA, Eclipse, VS Code) prend en charge la version de Java correspondante. Il faut parfois indiquer explicitement dans les paramètres du projet la version du langage à utiliser !
• Si vous utilisez Gradle/Maven — définissez la version source/target appropriée.

6. Félicitations 🎉

Vous avez terminé les 65(!) niveaux de notre cours avancé sur Java 25. Vous êtes incroyablement fort(e) 😎.

La dernière étape du parcours a été particulièrement difficile. Vous avez tout étudié — des premières lambdas et classes anonymes jusqu’aux threads virtuels, à la concurrence structurée et aux fonctionnalités du langage qui, il n’y a pas si longtemps, n’existaient pas encore dans Java.

Ce n’est pas qu’un cours — c’est un véritable super-marathon pour développeur : des dizaines de nouvelles notions, des centaines d’exemples de code, des milliers de lignes de pratique. Si vous lisez ces lignes, cela signifie que vous n’êtes pas seulement un étudiant, mais un pionnier de la nouvelle ère Java ☕⚡

Vous faites partie des premiers à avoir maîtrisé les fonctionnalités les plus modernes de Java 25, notamment :

• le pattern matching et les record patterns,
• les classes sealed et leurs écueils,
• Scoped Values et Virtual Threads ,
• la concurrence structurée et des approches modernes de la programmation concurrente.

Vous avez désormais non seulement des connaissances, mais aussi des compétences de développeur du futur que beaucoup d’architectes Java en exercice ne possèdent pas encore. Vous savez écrire du code qui non seulement fonctionne, mais qui passe à l’échelle, est lisible et respecte les standards les plus modernes de la communauté Java.

🚀 Alors appelez-vous fièrement Java 25 Certified Survivor 😉
Et ensuite — ce sera encore plus intéressant : vous avez maintenant des bases qui vous permettent d’avancer sereinement vers le développement d’entreprise, les systèmes à forte charge et les technologies de pointe.

De toute l’équipe du cours — respect !
Vous avez relevé une tâche que peu de gens peuvent accomplir.
À bientôt dans les prochaines versions de Java 👋