Java Academy · Lezione

switch in stile arrow

Utilizzi la moderna sintassi arrow di switch

switch in stile arrow è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 1 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.

Il problema del vecchio switch

L'istruzione Java switch classica usava etichette con i due punti e richiedeva break dopo ogni case. Dimenticare break causava bug di fall-through, in cui l'esecuzione passava direttamente al case successivo.

Java moderno (14+) introduce la sintassi con freccia, che risolve completamente questo problema.

Nozioni di base della sintassi con freccia

Con switch in stile freccia, ogni etichetta usa -> invece di :. Non si verifica alcun fall-through e non è necessario usare break. Ogni ramo esegue solo il proprio codice.

public class Main {
    public static void main(String[] args) {
        int day = 3;
        switch (day) {
            case 1 -> System.out.println("Monday");
            case 3 -> System.out.println("Wednesday");
            default -> System.out.println("Other day");
        }
    }
}

Niente più break

Nel vecchio stile era necessario scrivere break; dopo ogni case. La forma con freccia elimina completamente questo obbligo. Viene eseguito solo il ramo corrispondente.

public class Main {
    public static void main(String[] args) {
        char grade = 'B';
        switch (grade) {
            case 'A' -> System.out.println("Excellent");
            case 'B' -> System.out.println("Good");
            case 'C' -> System.out.println("Average");
            default -> System.out.println("Needs work");
        }
    }
}

Blocchi di istruzioni

Quando un ramo richiede più di un'istruzione, lo si racchiude tra parentesi graffe { }. Il blocco può contenere un numero qualsiasi di istruzioni.

public class Main {
    public static void main(String[] args) {
        int code = 2;
        switch (code) {
            case 2 -> {
                System.out.println("Processing code 2");
                System.out.println("Done");
            }
            default -> System.out.println("Unknown");
        }
    }
}

Usare switch con le stringhe

switch in stile freccia funziona con valori String proprio come il vecchio stile. I confronti usano internamente equals, quindi distinguono tra maiuscole e minuscole.

public class Main {
    public static void main(String[] args) {
        String fruit = "apple";
        switch (fruit) {
            case "apple" -> System.out.println("Red or green");
            case "banana" -> System.out.println("Yellow");
            default -> System.out.println("Unknown fruit");
        }
    }
}

Il ramo default

Il ramo default gestisce qualsiasi valore non coperto dagli altri case. È buona norma includerlo sempre, in modo da gestire elegantemente gli input imprevisti.

public class Main {
    public static void main(String[] args) {
        int level = 99;
        switch (level) {
            case 1 -> System.out.println("Beginner");
            case 2 -> System.out.println("Intermediate");
            default -> System.out.println("Unknown level: " + level);
        }
    }
}

Usare switch con gli enum

switch in stile freccia si abbina perfettamente ai tipi enum. È possibile omettere il prefisso con il nome dell'enum da ogni etichetta, mantenendo i rami brevi e ordinati.

public class Main {
    enum Color { RED, GREEN, BLUE }
    public static void main(String[] args) {
        Color c = Color.GREEN;
        switch (c) {
            case RED -> System.out.println("Stop");
            case GREEN -> System.out.println("Go");
            case BLUE -> System.out.println("Calm");
        }
    }
}

Chiamare metodi nei rami

Ogni ramo con freccia può chiamare qualsiasi metodo. In questo modo il switch resta leggibile, mentre il lavoro effettivo viene delegato altrove.

public class Main {
    static void greet(String who) {
        System.out.println("Hello, " + who);
    }
    public static void main(String[] args) {
        int who = 1;
        switch (who) {
            case 1 -> greet("Alice");
            case 2 -> greet("Bob");
            default -> greet("Stranger");
        }
    }
}

Più chiaro di if-else

switch in stile freccia spesso sostituisce lunghe catene di if-else. Quando si confronta una variabile con molti valori fissi, switch risulta più leggibile.

public class Main {
    public static void main(String[] args) {
        int month = 4;
        switch (month) {
            case 12, 1, 2 -> System.out.println("Winter");
            case 3, 4, 5 -> System.out.println("Spring");
            case 6, 7, 8 -> System.out.println("Summer");
            default -> System.out.println("Autumn");
        }
    }
}

Solo effetti collaterali

Un'istruzione switch (qui usata nella forma con freccia) esegue operazioni, ma non produce un valore. Per restituire un valore, si usa un'espressione switch, descritta nella lezione successiva.

public class Main {
    public static void main(String[] args) {
        int n = 5;
        switch (n % 2) {
            case 0 -> System.out.println(n + " is even");
            case 1 -> System.out.println(n + " is odd");
        }
    }
}

Più valori, un solo ramo

È possibile far condividere un ramo a più valori separandoli con virgole. Questa è un'anteprima dei case con più etichette, trattati più avanti.

public class Main {
    public static void main(String[] args) {
        char c = 'e';
        switch (c) {
            case 'a', 'e', 'i', 'o', 'u' -> System.out.println("Vowel");
            default -> System.out.println("Consonant");
        }
    }
}

Verifica rapida

Qual è il principale vantaggio di switch in stile freccia rispetto al vecchio stile con i due punti?

Riepilogo

Ha imparato la sintassi moderna di switch con freccia:

Usi -> invece di :
Nessun fall-through e nessun break necessario
Usi le parentesi graffe { } per i rami con più istruzioni
Separa le etichette con virgole per condividere un ramo
Includa sempre un ramo default

Domande Frequenti

La lezione «switch in stile arrow» è gratuita?

Sì — il testo completo di «switch in stile arrow» è 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 «switch in stile arrow»?

Utilizzi la moderna sintassi arrow di switch 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 1 di 4.

Quanto tempo richiede la lezione «switch in stile arrow»?

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

← Torna a Java Academy