Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / Java

Expression switch à règles fléchées

En Java SE 21, une expression `switch` produit une valeur. Les règles fléchées empêchent l’enchaînement des branches et permettent de regrouper plusieurs constantes d’énumération.

Version : Java SE 21

Syntaxe

ResultType result = switch (selector) {
    case CONSTANT_A -> expressionA;
    case CONSTANT_B, CONSTANT_C -> expressionBC;
};

Une expression switch à règles fléchées évalue d’abord le sélecteur entre parenthèses. Lorsqu’un case correspond, la valeur de l’expression après -> devient celle du switch entier. Elle peut servir à initialiser une variable. Le point-virgule après l’expression termine la règle ; celui après } termine la déclaration de la variable.

Dans case TEST, STAGING ->, la virgule indique que chacune des deux constantes sélectionne la même règle. L’exécution ne se poursuit pas dans la règle suivante : aucun break n’est nécessaire. Une instruction switch peut aussi utiliser des flèches, mais elle ne produit pas de valeur. La flèche seule ne suffit donc pas à reconnaître une expression. Les groupes case ...: peuvent s’enchaîner. On ne peut pas mélanger les deux formes dans un même switch.

Une expression switch doit être exhaustive. Si les étiquettes couvrent toutes les constantes d’un enum, default n’est pas obligatoire. Si vous ajoutez une constante, la recompilation échoue en l’absence d’une règle qui la couvre et de default. En Java SE 21, un sélecteur null sans case null déclenche une NullPointerException ; default seul ne traite pas null.

Une simple expression après -> n’a pas besoin de yield. Dans un bloc après la flèche, yield valeur; fournit un résultat à l’expression switch englobante, et non à la méthode appelante. Une règle peut aussi lever une exception avec throw. Le bloc d’une règle ne peut pas simplement atteindre son } final sans fournir de résultat.

Exemples

public class Main {
    public static void main(String[] args) {
        enum Environment { DEV, TEST, STAGING, PROD }

        for (Environment environment : Environment.values()) {
            String profile = switch (environment) {
                case DEV -> "local";
                case TEST, STAGING -> "pre-release";
                case PROD -> "live";
            };
            int retries = switch (environment) {
                case DEV -> 0;
                case TEST, STAGING -> 1;
                case PROD -> 3;
            };
            boolean debug = switch (environment) {
                case DEV -> true;
                case TEST, STAGING -> true;
                case PROD -> false;
            };
            System.out.println(environment + ": " + profile + ", " + retries + ", " + debug);
        }
    }
}

Résultat

DEV: local, 0, true
TEST: pre-release, 1, true
STAGING: pre-release, 1, true
PROD: live, 3, false

Trois expressions `switch` utilisent le même `enum` local. Chacune couvre les quatre constantes et initialise une variable : `profile`, `retries` ou `debug`. `TEST` et `STAGING` produisent les trois mêmes valeurs mais apparaissent sur des lignes distinctes.

Leçons associées

  • Java · Leçon 9 · Avancé · Version : 2

Sources