Expressions switch avec des énumérations

Expressions de sélection avec des énumérations

Instruction de sélection traditionnelle

enum Severity { LOW, MEDIUM, HIGH, CRITICAL }

Severity s = Severity.HIGH;
String action;
switch (s) {
    case LOW:
        action = "Log and monitor";
        break;
    case MEDIUM:
        action = "Notify on-call team";
        break;
    case HIGH:
        action = "Page engineer immediately";
        break;
    case CRITICAL:
        action = "Activate incident response";
        break;
    default:
        action = "Unknown";
}
System.out.println(action); // Page engineer immediately

Expression de sélection avec étiquettes fléchées

enum Severity { LOW, MEDIUM, HIGH, CRITICAL }

Severity s = Severity.HIGH;
String action = switch (s) {
    case LOW      -> "Log and monitor";
    case MEDIUM   -> "Notify on-call team";
    case HIGH     -> "Page engineer immediately";
    case CRITICAL -> "Activate incident response";
    // no default needed — all cases covered
};
System.out.println(action); // Page engineer immediately

Expression de sélection avec blocs

enum DayOfWeek { MON, TUE, WED, THU, FRI, SAT, SUN }

DayOfWeek day = DayOfWeek.FRI;
int hoursOpen = switch (day) {
    case MON, TUE, WED, THU -> 8;
    case FRI -> {
        System.out.println("Half day on Friday!");
        yield 4;  // yield returns value from block
    }
    case SAT, SUN -> 0;
};
System.out.println("Hours open: " + hoursOpen); // Hours open: 4

Regroupement de plusieurs cas

enum Season { SPRING, SUMMER, FALL, WINTER }

Season season = Season.SUMMER;
String activity = switch (season) {
    case SPRING, FALL -> "Hike in the mountains";
    case SUMMER       -> "Beach vacation";
    case WINTER       -> "Ski at the resort";
};
System.out.println(activity); // Beach vacation

Retour depuis des méthodes avec des expressions de sélection

enum Priority { LOW, NORMAL, HIGH, URGENT }

static int getSlaHours(Priority p) {
    return switch (p) {
        case LOW    -> 72;
        case NORMAL -> 24;
        case HIGH   -> 4;
        case URGENT -> 1;
    };
}

System.out.println(getSlaHours(Priority.URGENT)); // 1
System.out.println(getSlaHours(Priority.LOW));    // 72

Expression de sélection dans un flux

import java.util.*;
import java.util.stream.*;

enum Status { PENDING, ACTIVE, CLOSED }

record Account(String id, Status status) {}

List<Account> accounts = List.of(
    new Account("A1", Status.ACTIVE),
    new Account("A2", Status.PENDING),
    new Account("A3", Status.CLOSED)
);

accounts.stream()
    .map(a -> a.id() + ": " + switch (a.status()) {
        case ACTIVE  -> "\u2705 Live";
        case PENDING -> "\u23f3 Awaiting activation";
        case CLOSED  -> "\u274c Deactivated";
    })
    .forEach(System.out::println);

Exhaustivité à la compilation

enum Color { RED, GREEN, BLUE }  // add YELLOW here → compile error below

Color c = Color.GREEN;
// This switch is exhaustive for RED, GREEN, BLUE
// If you add YELLOW to the enum without adding a case here,
// the compiler will report an error.
String hex = switch (c) {
    case RED   -> "#FF0000";
    case GREEN -> "#00FF00";
    case BLUE  -> "#0000FF";
};
System.out.println(hex); // #00FF00

Expression de sélection avec un cas par défaut pour plus de sécurité

enum Feature { DARK_MODE, PUSH_NOTIFICATIONS, ANALYTICS, BETA_FEATURE }

static boolean isEnabled(Feature feature) {
    return switch (feature) {
        case DARK_MODE, PUSH_NOTIFICATIONS -> true;
        case ANALYTICS                     -> false;
        default -> {
            System.out.println("Unknown feature: " + feature);
            yield false;
        }
    };
}
System.out.println(isEnabled(Feature.DARK_MODE));     // true
System.out.println(isEnabled(Feature.BETA_FEATURE));  // false

En pratique : cycle de vie d’une commande

enum OrderState { CART, PENDING, CONFIRMED, SHIPPED, DELIVERED, CANCELLED }

static Set<OrderState> allowedTransitions(OrderState from) {
    return switch (from) {
        case CART      -> Set.of(OrderState.PENDING, OrderState.CANCELLED);
        case PENDING   -> Set.of(OrderState.CONFIRMED, OrderState.CANCELLED);
        case CONFIRMED -> Set.of(OrderState.SHIPPED);
        case SHIPPED   -> Set.of(OrderState.DELIVERED);
        case DELIVERED, CANCELLED -> Set.of(); // terminal states
    };
}
System.out.println(allowedTransitions(OrderState.PENDING));
// [CONFIRMED, CANCELLED]

Sélection selon une chaîne ou une énumération

// String switch — fragile
String role = "admin";
String label = switch (role.toLowerCase()) {
    case "admin" -> "Administrator";
    case "guest" -> "Guest User";
    default      -> "Unknown";
};

// Enum switch — type-safe
enum Role { ADMIN, GUEST }
Role r = Role.ADMIN;
String label2 = switch (r) {
    case ADMIN -> "Administrator";
    case GUEST -> "Guest User";
};
System.out.println(label2); // Administrator

Vérification rapide

Récapitulatif : expressions de sélection avec des énumérations