Réponse.

Histoire de la question

Le pattern matching est une technique empruntée aux langages fonctionnels et de script, permettant de vérifier le type et d'extraire des données en une seule étape. En Java, le développement du pattern matching a commencé avec Java 14 (fonctionnalité en avant-première), s'est amélioré dans Java 16–17, et dans les dernières versions, il s'élargit sur switch.

Problème

La façon classique de vérifier le type et de le transformer était lourde :

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

Cela engendrait des variables superflues, une grande quantité de code répétitif, et un risque d'erreurs de conversion de type.

Solution

Le pattern matching permet de combiner la vérification du type, la déclaration d'une nouvelle variable et son utilisation en une seule expression :

if (obj instanceof String s) {
    System.out.println(s.length());
}

Des motifs similaires apparaissent maintenant dans la construction switch, ce qui rend le code plus concis et moins sujet aux erreurs.

Caractéristiques clés :

Travail concis et sécurisé avec les types.
Réduction du nombre d'erreurs lors des conversions.
Simplicité de maintenance du code et extensibilité aux nouveaux types.

Questions piégeuses.

Peut-on utiliser le pattern matching pour des classes personnalisées ou uniquement pour des types standards ?

On peut l'utiliser pour n'importe quelle classe. Le Pattern Matching fonctionne pour toutes les classes sur lesquelles on peut utiliser instanceof.

La variable de motif sera-t-elle accessible en dehors du bloc if/switch ?

Non, la variable déclarée à l'intérieur du pattern matching n'est visible que dans la portée du bloc où elle a été créée (par exemple, dans un if ou un case switch).

Exemple de code :

if (obj instanceof Integer i) {
    // i est visible uniquement dans ce bloc
    System.out.println(i + 10);
}
// Ici, i n'est pas accessible

Peut-on utiliser le pattern matching avec des génériques ?

Oui, comme ceci :

Object list = List.of("a", "b");
if (list instanceof List<?> l) {
    System.out.println(l.size());
}

Mais le travail avec des types bruts et la conversion en types paramétrés restent limités en raison de l'effacement des types.

Erreurs typiques et anti-patterns

Supposer que le pattern matching gère automatiquement les null : si l'objet est égal à null, la condition ne sera pas satisfaite (instanceof avec null est toujours faux).
Utiliser le pattern matching là où il suffirait d'utiliser la méthode getClass().
Une utilisation fréquente du pattern matching peut nuire à l'architecture si les intentions ne sont pas claires.

Exemple de la vie réelle

Cas négatif

L'équipe a intégré le pattern matching dans tous les cas, y compris les DTO internes, les classes de service et dans des situations où le polymorphisme était suffisant. Le code est devenu trop lié à instanceof, le rôle des hiérarchies de classes est flou.

Avantages :

Intégration rapide.
Style concis.

Inconvénients :

Erreurs architecturales.
Moins de lisibilité.

Cas positif

Dans le projet, le pattern matching a été appliqué uniquement pour des interfaces générales, des utilitaires auxiliaires et le traitement de collections de type inconnu. L'architecture OOP est préservée, le pattern n'est utilisé que là où il est indispensable.