0Pricing
Java Academy · Lezione

Espressioni switch con gli enum

Utilizzi le moderne espressioni switch con gli enum per creare diramazioni chiare ed esaustive.

Espressioni switch con gli enum è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.

Espressioni switch con gli enum

Le espressioni switch (Java 14+) con gli enum forniscono un instradamento conciso basato sui tipi e verificabile per esaustività. Quando sono coperte tutte le costanti enum, non è necessario default.

Istruzione switch tradizionale

La classica istruzione switch funziona con gli enum, ma richiede break per impedire il fall-through.

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

Espressione switch con etichette freccia

Le espressioni switch con etichette freccia eliminano il fall-through e break. Restituiscono un valore e richiedono che tutti i casi siano gestiti.

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

Espressione switch con blocchi

Quando la logica di un case richiede più istruzioni, usi un blocco con yield per produrre il valore risultante.

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

Raggruppare più casi

Più costanti enum possono condividere lo stesso caso separandole con virgole.

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

Restituire valori dai metodi con switch

Le espressioni switch sono ideali come istruzioni return nei metodi e rendono chiaro l'intento.

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

Espressione switch in uno stream

Le espressioni switch possono essere utilizzate all'interno delle operazioni sugli stream per trasformare ogni elemento in modo chiaro.

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);

Completezza verificata in fase di compilazione

Il compilatore verifica che tutte le costanti enum siano gestite. L'aggiunta di una nuova costante a un enum causa errori di compilazione in tutte le espressioni switch che non la gestiscono.

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

Switch con default per sicurezza

Quando si utilizza un'istruzione switch (non un'espressione) oppure quando lo switch copre intenzionalmente solo alcuni casi, aggiunga un caso default.

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

Pratica: ciclo di vita di un ordine

Una macchina a stati completa per il ciclo di vita di un ordine, che utilizza un'espressione switch per determinare le transizioni consentite.

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]

Switch su String rispetto a enum

Uno switch su una String richiede un controllo su null ed è sensibile alle maiuscole e alle minuscole. Uno switch su un enum è sicuro rispetto a null (genera NPE se il valore è null) e garantisce la sicurezza dei tipi: preferisca gli enum quando l'insieme di valori è noto.

// 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

Verifica rapida

Si dispone di un enum con 4 costanti e si scrive un'espressione switch che le copre tutte e 4. Cosa succede se si aggiunge una quinta costante all'enum?

Riepilogo: espressioni switch con enum

Punti chiave:

  • Le espressioni switch con label a freccia eliminano break e fall-through
  • Utilizzi yield per restituire un valore da un caso con blocco
  • Raggruppi più costanti con le virgole: case A, B ->
  • Le espressioni switch complete non richiedono default quando tutte le costanti sono gestite
  • L'aggiunta di una nuova costante enum causa errori di compilazione nelle espressioni switch complete
  • Le espressioni switch sono ideali nelle operazioni map() sugli stream

Domande Frequenti

La lezione «Espressioni switch con gli enum» è gratuita?

Sì — il testo completo di «Espressioni switch con gli enum» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.

Cosa imparerò in «Espressioni switch con gli enum»?

Utilizzi le moderne espressioni switch con gli enum per creare diramazioni chiare ed esaustive. Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Espressioni switch con gli enum»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Definizione e utilizzo degli enum
  2. Enum con campi e metodi
  3. Espressioni switch con gli enum
  4. EnumSet ed EnumMap
← Torna a Java Academy