Instruction switch en Java : cas, fall-through et syntaxe fléchée

À quoi sert switch

Un switch compare une valeur à une liste d'options fixes et exécute la branche qui correspond. Lorsque vous vous surprenez à écrire une longue chaîne if/else if qui teste sans cesse la même variable contre différentes constantes, un switch dit la même chose plus clairement.

Il ne fait que des vérifications d'égalité contre des constantes connues à la compilation : il ne peut pas tester des intervalles ni combiner des conditions. Pour cela, restez avec if/else.

L'instruction switch classique

La forme traditionnelle utilise des étiquettes case avec des deux-points et un break après chaque branche :

public class Main {
    public static void main(String[] args) {
        int day = 3;

        switch (day) {
            case 1:
                System.out.println("Monday");
                break;
            case 2:
                System.out.println("Tuesday");
                break;
            case 3:
                System.out.println("Wednesday");
                break;
            default:
                System.out.println("Some other day");
        }
    }
}

Java évalue day, saute au case correspondant, exécute ses instructions, et le break sort du switch. La branche default s'exécute lorsque rien d'autre ne correspond : voyez-la comme le else. Elle est facultative, mais l'inclure est une bonne pratique pour que les valeurs inattendues ne passent pas silencieusement.

Le piège du break : le fall-through

C'est le bug de switch le plus courant de tous. Si vous omettez un break, l'exécution ne s'arrête pas à la fin d'un case correspondant : elle traverse vers le case suivant et continue à s'exécuter jusqu'à rencontrer un break ou l'accolade de fermeture :

public class Main {
    public static void main(String[] args) {
        int level = 1;

        switch (level) {
            case 1:
                System.out.println("Level 1");
                // no break - falls through!
            case 2:
                System.out.println("Level 2");
            case 3:
                System.out.println("Level 3");
                break;
        }
    }
}

Vous pourriez vous attendre uniquement à Level 1, mais ceci affiche les trois lignes. Comme case 1 n'a pas de break, le contrôle glisse directement vers case 2 et case 3. Ajoutez toujours un break à moins de vouloir réellement le fall-through ; et lorsque vous comptez dessus, laissez un commentaire pour que le prochain lecteur sache que c'était intentionnel.

Regrouper les cas

Le fall-through a un usage légitime et soigné : empiler les étiquettes case pour que plusieurs valeurs partagent un même bloc. Placez les étiquettes les unes après les autres sans code entre elles :

public class Main {
    public static void main(String[] args) {
        char grade = 'B';

        switch (grade) {
            case 'A':
            case 'B':
            case 'C':
                System.out.println("Pass");
                break;
            case 'D':
            case 'F':
                System.out.println("Fail");
                break;
            default:
                System.out.println("Unknown grade");
        }
    }
}

Ici 'A', 'B' et 'C' exécutent tous la même ligne "Pass". C'est la manière prévue de dire « n'importe laquelle de ces valeurs fait la même chose ».

switch sur des String

Vous n'êtes pas limité aux nombres. Depuis Java 7, vous pouvez faire un switch sur un String, ce qui est parfait pour des choix de menu ou des noms de commandes :

public class Main {
    public static void main(String[] args) {
        String command = "stop";

        switch (command) {
            case "start":
                System.out.println("Starting...");
                break;
            case "stop":
                System.out.println("Stopping...");
                break;
            default:
                System.out.println("Unknown command: " + command);
        }
    }
}

La comparaison est sensible à la casse : "Stop" ne correspondrait pas à "stop", alors normalisez d'abord (par exemple command.toLowerCase()) si la casse de l'entrée varie. Un autre piège : si command vaut null, le switch lève une NullPointerException, alors protégez-vous contre null avant d'y arriver.

La syntaxe fléchée moderne

Java plus récent (14+) ajoute une forme fléchée, case label -> ..., qui corrige par conception le piège du fall-through. Chaque case fléché exécute exactement une branche et ne traverse jamais, donc il n'y a aucun break à oublier :

public class Main {
    public static void main(String[] args) {
        int day = 6;

        switch (day) {
            case 1, 2, 3, 4, 5 -> System.out.println("Weekday");
            case 6, 7          -> System.out.println("Weekend");
            default            -> System.out.println("Invalid day");
        }
    }
}

Remarquez que vous regroupez les valeurs avec une virgule (case 6, 7) au lieu d'empiler les étiquettes, et il n'y a pas le moindre break en vue. Pour plusieurs instructions, utilisez un bloc : case 1 -> { ...; ... }. Préférez cette forme dans le nouveau code : elle est plus courte et élimine toute une catégorie de bugs.

switch comme expression

La forme fléchée peut aussi produire une valeur. Une expression switch renvoie un résultat que vous pouvez affecter directement à une variable : pas de temporaire, pas d'affectation répétée dans chaque branche :

public class Main {
    public static void main(String[] args) {
        int month = 4;

        int days = switch (month) {
            case 1, 3, 5, 7, 8, 10, 12 -> 31;
            case 4, 6, 9, 11           -> 30;
            case 2                     -> 28;
            default -> throw new IllegalArgumentException("Bad month: " + month);
        };

        System.out.println("Days: " + days);
    }
}

Tout le switch (...) { ... } s'évalue en un nombre stocké dans days. Notez le point-virgule après l'accolade de fermeture : il fait partie de l'instruction d'affectation. Une expression switch doit être exhaustive (couvrir toutes les valeurs possibles), c'est pourquoi le default est ici. Si une branche a besoin de plusieurs instructions avant de renvoyer une valeur, utilisez un bloc avec yield :

case 2 -> {
    boolean leap = (year % 4 == 0);
    yield leap ? 29 : 28;
}

yield est la manière dont un bloc fléché renvoie sa valeur, l'équivalent dans le monde des expressions du break qui transporte un résultat.

Ensuite : les boucles for

switch choisit une branche parmi plusieurs ; parfois, au contraire, vous avez besoin de répéter un bloc de nombreuses fois. La boucle for exécute du code un nombre contrôlé de fois (en parcourant un intervalle ou en passant sur chaque élément) et c'est la page suivante.