La correspondance de modèles est une fonctionnalité puissante introduite dans Java qui vous permet de simplifier et d'améliorer la lisibilité de votre code. Initialement introduite dans Java 14 pour les vérifications d'instance et étendue dans les versions ultérieures, la correspondance de modèles permet un code plus expressif et concis en réduisant le passe-partout.

Qu'est-ce que la correspondance de modèles ?

La correspondance de modèles vous permet d'extraire des composants d'objets et d'appliquer certaines conditions de manière concise. Il s'agit d'une fonctionnalité qui vérifie une valeur par rapport à un modèle et, si la correspondance réussit, lie les variables du modèle.

Avantages de la correspondance de modèles

1. Code concis : réduit le code passe-partout, rendant vos programmes plus courts et plus faciles à lire.
2. Lisibilité améliorée : améliore la clarté de votre code en rendant la structure plus apparente.
3. Sécurité des types : garantit que les variables sont correctement saisies, réduisant ainsi le risque d'erreurs d'exécution.

Correspondance de modèle avec instanceof

L'une des utilisations les plus courantes de la correspondance de modèles est l'opérateur instanceof. Voici un exemple :

public class PatternMatchingExample {
    public static void main(String[] args) {
        Object obj = "Hello, World!";

        if (obj instanceof String s) {
            System.out.println("The string is: "   s);
        } else {
            System.out.println("Not a string");
        }
    }
}

Dans cet exemple, l'opérateur instanceof vérifie non seulement si obj est une chaîne, mais le convertit également en chaîne et le lie à la variable s en une seule étape.

Correspondance de modèles avec des expressions de commutation

La correspondance de modèles est également utilisée avec les expressions de commutation, améliorant ainsi leur puissance et leur flexibilité. Voici un exemple utilisant des classes scellées :

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

public final class Circle extends Shape {
    private final double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    public double radius() { return radius; }
}

public final class Rectangle extends Shape {
    private final double width, height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    public double width() { return width; }
    public double height() { return height; }
}

public final class Square extends Shape {
    private final double side;

    public Square(double side) {
        this.side = side;
    }

    public double side() { return side; }
}

public class PatternMatchingWithSwitch {
    public static void main(String[] args) {
        Shape shape = new Circle(5);

        String result = switch (shape) {
            case Circle c -> "Circle with radius "   c.radius();
            case Rectangle r -> "Rectangle with width "   r.width()   " and height "   r.height();
            case Square s -> "Square with side "   s.side();
        };

        System.out.println(result);
    }
}

Dans cet exemple, l'expression switch utilise la correspondance de modèles pour déstructurer les objets Shape et extraire les données pertinentes.

Conclusion

La correspondance de modèles en Java apporte un nouveau niveau d'expressivité et de simplicité à votre code. En réduisant le passe-partout et en améliorant la lisibilité, il vous permet d'écrire des programmes plus propres et plus maintenables. Que vous travailliez avec des structures de données complexes ou que vous essayiez simplement de rationaliser vos vérifications de type, la correspondance de modèles est un outil précieux dans votre boîte à outils Java.