Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Espressione switch con regole a freccia

In Java SE 21, un’espressione `switch` produce un valore. Le regole con `->` evitano il passaggio al ramo successivo e raggruppano più costanti di un `enum`.

Versione: Java SE 21

Sintassi

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

Un’espressione switch con regole a freccia valuta prima il selettore tra parentesi. Quando c’è un case corrispondente, il valore dell’espressione dopo -> diventa il valore dell’intero switch. Puoi usarlo per inizializzare una variabile. Il punto e virgola dopo l’espressione chiude la regola; quello dopo } chiude la dichiarazione della variabile.

In case TEST, STAGING ->, la virgola indica che entrambe le costanti selezionano la stessa regola. L’esecuzione non prosegue nella regola successiva, quindi non serve break. Anche un’istruzione switch può usare le frecce, ma non produce un valore: la freccia da sola non identifica un’espressione. I gruppi case ...: possono proseguire nel gruppo successivo. Le due forme non si possono mescolare nello stesso switch.

Un’espressione switch deve essere esaustiva. Se le etichette coprono tutte le costanti di un enum, default non è necessario. Se aggiungi una costante, la ricompilazione fallisce quando mancano sia una regola che la copra sia default. In Java SE 21, un selettore null senza case null causa una NullPointerException; default da solo non gestisce null.

Una semplice espressione dopo -> non richiede yield. In un blocco dopo la freccia, yield valore; fornisce il risultato all’espressione switch che lo contiene, non al metodo chiamante. Una regola può anche lanciare un’eccezione con throw. Un blocco di regola non può semplicemente raggiungere la propria } di chiusura senza fornire un risultato.

Esempi

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

Risultato

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

Tre espressioni `switch` usano lo stesso `enum` locale. Ognuna copre tutte e quattro le costanti e inizializza una variabile: `profile`, `retries` o `debug`. `TEST` e `STAGING` producono gli stessi tre valori, ma compaiono su righe separate.

Lezioni correlate

  • Java · Lezione 9 · Avanzato · Versione: 2

Fonti