Switch classico: sintassi, esempi

1. Introduzione

Immaginate: state scrivendo un programma per una caffetteria. L'utente può scegliere una bevanda e voi dovete reagire a questa scelta. Si può, certo, usare un mucchio di if-else if-else, ma non è molto elegante:

if (choice == 1) 
{
    System.out.println("Hai scelto un espresso.");
} 
else if (choice == 2) 
{
    System.out.println("Hai scelto un cappuccino.");
} 
else if (choice == 3) 
{
    System.out.println("Hai scelto un latte.");
} 
else 
{
    System.out.println("Questa bevanda non esiste.");
}

Ammettetelo, è piuttosto macchinoso. E se le opzioni fossero 10 o 20? È qui che entra in gioco l'operatore switch, che consente di implementare in modo elegante e compatto la scelta tra molte alternative in base al valore di una variabile.

Sintassi dello switch classico

La sintassi di switch in Java è la seguente:

switch (espressione) 
{
    case valore1:
        // azioni se espressione == valore1
        break;
    case valore2:
        // azioni se espressione == valore2
        break;
    ...
    default:
        // azioni se non corrisponde a nessun case
        break;
}

Elementi chiave:

• switch (espressione) — l'espressione il cui risultato viene confrontato con ogni case.
• case valore: — un'alternativa con cui viene confrontata l'espressione.
• break; — termina l'esecuzione del blocco switch (altrimenti — «fall-through» nel case successivo).
• default: — viene eseguito se non c'è corrispondenza con alcun case.

2. Esempi di utilizzo di switch

Esempio 1: Un classico — scelta della bevanda

Implementiamo un menu per una caffetteria:

import java.util.Scanner;

public class CoffeeShop 
{
    public static void main(String[] args) 
    {
        Scanner console = new Scanner(System.in);

        System.out.println("Scegli una bevanda:");
        System.out.println("1 - Espresso");
        System.out.println("2 - Cappuccino");
        System.out.println("3 - Latte");
        int choice = console.nextInt();

        switch (choice) 
        {
            case 1:
                System.out.println("Hai scelto un espresso.");
                break;
            case 2:
                System.out.println("Hai scelto un cappuccino.");
                break;
            case 3:
                System.out.println("Hai scelto un latte.");
                break;
            default:
                System.out.println("Questa bevanda non esiste.");
                break;
        }
    }
}

Cosa succede:

• L'utente inserisce il numero della bevanda.
• Il valore della variabile choice viene confrontato con ciascun case.
• Se c'è corrispondenza, viene eseguito il blocco corrispondente e poi break termina l'esecuzione di switch.
• Se non c'è corrispondenza con nessuno, viene eseguito default.

Esempio 2: Switch su stringhe

Non ci sono molti tipi che si possono usare dentro switch, ma le stringhe — sì! È comodo per i menu a comandi:

import java.util.Scanner;

public class CommandMenu 
{
    public static void main(String[] args) 
    {
        Scanner console = new Scanner(System.in);

        System.out.println("Inserisci un comando (start, stop, pause):");
        String command = console.nextLine();

        switch (command) 
        {
            case "start":
                System.out.println("Avvio del programma!");
                break;
            case "stop":
                System.out.println("Arresto del programma.");
                break;
            case "pause":
                System.out.println("Pausa.");
                break;
            default:
                System.out.println("Comando sconosciuto.");
                break;
        }
    }
}

Attenzione: il confronto di stringhe in switch è case-sensitive! "Start" e "start" — stringhe diverse.

3. Quali tipi supporta lo switch classico?

Nello switch classico si possono usare solo determinati tipi:

• Tipi primitivi interi: byte, short, char, int
• Enumerazioni: enum (ne parleremo nella prossima lezione)
• Stringhe: String — il confronto è case-sensitive

Non si possono usare: boolean, float, double, array, oggetti di classi arbitrarie (tranne enum e String).

Esempio con char

char grade = 'B';

switch (grade) 
{
    case 'A':
        System.out.println("Eccellente!");
        break;
    case 'B':
        System.out.println("Buono.");
        break;
    case 'C':
        System.out.println("Sufficiente.");
        break;
    default:
        System.out.println("Riprova.");
        break;
}

4. Obbligatorietà break: cosa succede se lo si dimentica?

L'errore più comune dei principianti — dimenticare break;. Vediamo cosa succede:

int day = 2;

switch (day) 
{
    case 1:
        System.out.println("Lunedì");
        break;
    case 2:
        System.out.println("Martedì");
    case 3:
        System.out.println("Mercoledì");
        break;
    default:
        System.out.println("Giorno sconosciuto");
        break;
}

Risultato:

Martedì
Mercoledì

Perché? Perché dopo case 2 non c'è break, e l'esecuzione «cade» nel case successivo (questo si chiama fall-through). A volte è utile, ma più spesso — un errore.

5. Raggruppare case: quando più alternative si comportano allo stesso modo

Se per più valori serve lo stesso comportamento, puoi elencarli uno dopo l'altro:

int month = 1;

switch (month) 
{
    case 12:
    case 1:
    case 2:
        System.out.println("Inverno");
        break;
    case 3:
    case 4:
    case 5:
        System.out.println("Primavera");
        break;
    case 6:
    case 7:
    case 8:
        System.out.println("Estate");
        break;
    case 9:
    case 10:
    case 11:
        System.out.println("Autunno");
        break;
    default:
        System.out.println("Mese sconosciuto");
        break;
}

Qui: se month — 12, 1 o 2, il programma stamperà "Inverno".

6. Confronto: switch e if-else

7. Errori tipici nell'uso di switch

Errore n. 1: si è dimenticato break
La causa più frequente di bug: ci si dimentica break — e il codice esegue un case diverso da quello atteso.

Errore n. 2: tipo non supportato
Provate a usare double, float o boolean — il compilatore dirà «non si può».

Errore n. 3: stringhe con maiuscole/minuscole diverse
L'utente inserisce "Start", ma voi vi aspettate "start" — lo switch non funzionerà. Meglio convertire le stringhe a un unico caso (ad esempio minuscolo) in anticipo:

switch (command.toLowerCase()) 
{
    case "start":
        // ...
}

Errore n. 4: variabile in case invece di costante
In case sono ammesse solo costanti. Se si usa una variabile, si ottiene un errore di compilazione.

Errore n. 5: case duplicati
Due valori case identici — il compilatore non lo perdonerà.