Instrukcja switch w Javie: case, fall-through i składnia strzałkowa

Do czego służy switch

switch porównuje jedną wartość z listą stałych opcji i wykonuje gałąź, która pasuje. Gdy łapiesz się na pisaniu długiego łańcucha if/else if, który w kółko sprawdza tę samą zmienną z różnymi stałymi, switch wyrazi to samo czytelniej.

Sprawdza wyłącznie równość ze stałymi znanymi w czasie kompilacji: nie przetestuje zakresów ani nie połączy warunków. Do tego zostań przy if/else.

Klasyczna instrukcja switch

Tradycyjna forma używa etykiet case z dwukropkiem i break po każdej gałęzi:

public class Main {
    public static void main(String[] args) {
        int day = 3;

        switch (day) {
            case 1:
                System.out.println("Monday");
                break;
            case 2:
                System.out.println("Tuesday");
                break;
            case 3:
                System.out.println("Wednesday");
                break;
            default:
                System.out.println("Some other day");
        }
    }
}

Java oblicza day, przeskakuje do pasującego case, wykonuje jego instrukcje, a break kończy switcha. Gałąź default wykonuje się, gdy nic innego nie pasuje: traktuj ją jak else. Jest opcjonalna, ale warto ją dodawać, żeby nieoczekiwane wartości nie prześlizgnęły się po cichu.

Pułapka z break: fall-through

To najczęstszy błąd przy switch. Jeśli pominiesz break, wykonanie nie zatrzyma się na końcu pasującego przypadku: przechodzi dalej (fall-through) do następnego i działa, aż trafi na break albo zamykający nawias klamrowy:

public class Main {
    public static void main(String[] args) {
        int level = 1;

        switch (level) {
            case 1:
                System.out.println("Level 1");
                // no break - falls through!
            case 2:
                System.out.println("Level 2");
            case 3:
                System.out.println("Level 3");
                break;
        }
    }
}

Można by się spodziewać samego Level 1, ale program wypisuje wszystkie trzy linie. Ponieważ case 1 nie ma break, sterowanie zjeżdża prosto do case 2 i case 3. Zawsze dodawaj break, chyba że naprawdę chcesz fall-through, a gdy na nim polegasz, zostaw komentarz, żeby następna osoba czytająca kod wiedziała, że to celowe.

Grupowanie przypadków

Fall-through ma jedno uzasadnione, eleganckie zastosowanie: ułożenie kilku etykiet case jedna pod drugą, tak aby kilka wartości dzieliło jeden blok. Wstaw etykiety bezpośrednio po sobie, bez kodu pomiędzy:

public class Main {
    public static void main(String[] args) {
        char grade = 'B';

        switch (grade) {
            case 'A':
            case 'B':
            case 'C':
                System.out.println("Pass");
                break;
            case 'D':
            case 'F':
                System.out.println("Fail");
                break;
            default:
                System.out.println("Unknown grade");
        }
    }
}

Tutaj 'A', 'B' i 'C' wykonują tę samą linię "Pass". Tak właśnie zapisuje się "każda z tych wartości robi to samo".

switch na stringach

Nie musisz ograniczać się do liczb. Od Javy 7 możesz użyć switcha na String, co świetnie sprawdza się przy opcjach menu albo nazwach poleceń:

public class Main {
    public static void main(String[] args) {
        String command = "stop";

        switch (command) {
            case "start":
                System.out.println("Starting...");
                break;
            case "stop":
                System.out.println("Stopping...");
                break;
            default:
                System.out.println("Unknown command: " + command);
        }
    }
}

Porównanie rozróżnia wielkość liter: "Stop" nie pasuje do "stop", więc gdy wielkość liter na wejściu bywa różna, najpierw ją ujednolić (np. command.toLowerCase()). Jeszcze jedna pułapka: jeśli command ma wartość null, switch rzuca NullPointerException, więc zabezpiecz się przed null, zanim do niego dojdziesz.

Nowoczesna składnia strzałkowa

Nowsza Java (14+) dodaje formę ze strzałką, case label -> ..., która z założenia usuwa pułapkę fall-through. Każdy przypadek ze strzałką wykonuje dokładnie jedną gałąź i nigdy nie przechodzi dalej, więc nie ma żadnego break, o którym można zapomnieć:

public class Main {
    public static void main(String[] args) {
        int day = 6;

        switch (day) {
            case 1, 2, 3, 4, 5 -> System.out.println("Weekday");
            case 6, 7          -> System.out.println("Weekend");
            default            -> System.out.println("Invalid day");
        }
    }
}

Zwróć uwagę, że wartości grupujesz przecinkiem (case 6, 7) zamiast układać etykiety jedna pod drugą, i nie ma tu ani jednego break. Dla kilku instrukcji użyj bloku: case 1 -> { ...; ... }. W nowym kodzie wybieraj tę formę: jest krótsza i eliminuje całą klasę błędów.

switch jako wyrażenie

Forma strzałkowa może też zwracać wartość. Wyrażenie switch daje wynik, który przypiszesz od razu do zmiennej: bez zmiennej tymczasowej i bez powtarzania przypisania w każdej gałęzi:

public class Main {
    public static void main(String[] args) {
        int month = 4;

        int days = switch (month) {
            case 1, 3, 5, 7, 8, 10, 12 -> 31;
            case 4, 6, 9, 11           -> 30;
            case 2                     -> 28;
            default -> throw new IllegalArgumentException("Bad month: " + month);
        };

        System.out.println("Days: " + days);
    }
}

Całe switch (...) { ... } daje liczbę zapisaną w days. Zauważ średnik po zamykającym nawiasie klamrowym: należy do instrukcji przypisania. Wyrażenie switch musi być wyczerpujące (obejmować każdą możliwą wartość), dlatego jest tu default. Zwróć też uwagę, że niepasująca gałąź może rzucić wyjątek zamiast zwracać wartość. Jeśli gałąź potrzebuje kilku instrukcji przed zwróceniem wartości, użyj bloku z yield:

case 2 -> {
    boolean leap = (year % 4 == 0);
    yield leap ? 29 : 28;
}

yield to sposób, w jaki blok strzałkowy oddaje swoją wartość: odpowiednik break ze świata wyrażeń, który niesie wynik.

Dalej: pętle for

switch wybiera jedną gałąź spośród wielu, a czasem trzeba zamiast tego powtórzyć blok wiele razy. Pętla for wykonuje kod kontrolowaną liczbę razy, przechodząc przez zakres albo po kolei przez każdy element, i to jej dotyczy następna strona.