Correspondance de modèles pour Switch dans Java 21

La correspondance de modèles est une fonctionnalité très attendue de Java, apportant plus de puissance et de flexibilité au langage. Java 21 introduit la correspondance de modèles pour les instructions switch, ce qui simplifie le code et réduit le passe-partout. Explorons comment cette nouvelle fonctionnalité fonctionne et pourquoi elle est bénéfique.

Qu’est-ce que la correspondance de modèles pour Switch ?

La correspondance de modèles pour switch vous permet de faire correspondre une valeur à des modèles, rendant le code plus expressif et lisible. Au lieu d'utiliser plusieurs instructions if-else ou des cas de commutation complexes, vous pouvez désormais écrire un code plus concis et plus maintenable.

Avantages de la correspondance de modèles pour Switch

• Lisibilité : Rend le code plus facile à lire et à comprendre.
• Concision : réduit la quantité de code passe-partout.
• Sécurité des types : Fournit une meilleure vérification de type au moment de la compilation.

Comment utiliser la correspondance de modèles pour Switch

Voici un exemple simple pour illustrer le fonctionnement de la correspondance de modèles pour switch :

static String formatterPatternSwitch(Object obj) {
    return switch (obj) {
        case Integer i -> String.format("int %d", i);
        case Long l    -> String.format("long %d", l);
        case Double d  -> String.format("double %f", d);
        case String s  -> String.format("String %s", s);
        default        -> obj.toString();
    };
}

Dans cet exemple, formatterPatternSwitch prend un objet et renvoie une chaîne formatée en fonction de son type. Voici un aperçu de ce qui se passe :

1. Switch Expression : L'expression switch prend l'objet et le compare à différents modèles.
2. Modèles de cas : chaque cas spécifie un modèle correspondant :
   • Integer i : correspond si obj est une instance d'Integer et lie la valeur à i.
   • Long l : correspond si obj est une instance de Long et lie la valeur à l.
   • Double d : correspond si obj est une instance de Double et lie la valeur à d.
   • String s : correspond si obj est une instance de String et lie la valeur à s.
3. Cas par défaut : le cas par défaut gère toutes les valeurs qui ne correspondent pas aux modèles spécifiés, en les convertissant en chaîne à l'aide de obj.toString().

Donnons-moi un exemple de cas détaillé : Gestion de différentes formes

Envisagez un scénario dans lequel vous devez gérer différentes formes et calculer leurs aires. Voici comment la correspondance de modèles pour switch peut simplifier le code :

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

final class Circle extends Shape {
    double radius;
    Circle(double radius) { this.radius = radius; }
}

final class Square extends Shape {
    double side;
    Square(double side) { this.side = side; }
}

final class Rectangle extends Shape {
    double length, width;
    Rectangle(double length, double width) { this.length = length; this.width = width; }
}

static double calculateArea(Shape shape) {
    return switch (shape) {
        case Circle c -> Math.PI * c.radius * c.radius;
        case Square s -> s.side * s.side;
        case Rectangle r -> r.length * r.width;
    };
}

Dans cet exemple :

1. Classes scellées : Shape est une classe scellée, et seuls Circle, Square et Rectangle peuvent l'étendre.
2. Switch Expression : La méthode calculateArea utilise une expression switch pour déterminer le type de forme et calculer son aire.
3. Modèles de cas : chaque cas correspond à un type de forme spécifique et effectue le calcul de la surface correspondante :
   • Cercle c : correspond si la forme est un Cercle et le lie à c, calcule l'aire en utilisant c.radius
   • Carré s : correspond si la forme est un Carré et le lie à s, calcule l'aire en utilisant s.side
   • Rectangle r : correspond si la forme est un Rectangle et le lie à r, calcule l'aire en utilisant r.length et r.width.

Conclusion

La correspondance de modèles pour switch dans Java 21 est une fonctionnalité puissante qui améliore la lisibilité du code, la concision et la sécurité des types. En vous permettant de faire correspondre les valeurs avec des modèles directement dans les instructions switch, cela simplifie de nombreuses tâches de codage courantes. Les développeurs Java devraient absolument explorer et adopter cette fonctionnalité pour écrire un code plus propre et plus maintenable.

N'hésitez pas à modifier ou développer cette section en fonction de vos besoins !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!