Java Academy · Lekcja

Przypadki z wieloma etykietami

Grupuj kilka etykiet

Przypadki z wieloma etykietami to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Java Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Java Academy zawiera 4 lekcji w sumie.

Grupowanie etykiet

Często kilka wartości powinno wywoływać to samo działanie. Nowoczesna instrukcja switch pozwala umieścić wiele etykiet w jednym przypadku, rozdzielając je przecinkami i współdzieląc jedną gałąź.

Etykiety rozdzielane przecinkami

Wartości należy zapisać kolejno, rozdzielając je przecinkami przed ->. Jeśli dowolna z nich pasuje, wykonywana jest ta gałąź.

public class Main {
    public static void main(String[] args) {
        int day = 7;
        switch (day) {
            case 1, 2, 3, 4, 5 -> System.out.println("Weekday");
            case 6, 7 -> System.out.println("Weekend");
        }
    }
}

Wykrywanie samogłosek

Klasyczny przykład zastosowania: pogrupowanie wszystkich samogłosek w jednej gałęzi zamiast zapisywania pięciu osobnych przypadków.

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

Wiele etykiet w wyrażeniach

Przypadki z wieloma etykietami działają również w wyrażeniach switch, zwracając tę samą wartość dla każdej z wymienionych etykiet.

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

Grupowanie etykiet napisowych

Wartości typu String również można grupować. W tym przykładzie kilka zapisów polecenia jest mapowanych na jedno działanie.

public class Main {
    public static void main(String[] args) {
        String cmd = "quit";
        switch (cmd) {
            case "quit", "exit", "q" -> System.out.println("Closing");
            case "help", "h" -> System.out.println("Showing help");
            default -> System.out.println("Unknown command");
        }
    }
}

Grupowanie etykiet enumów

Stałe enumów również mogą współdzielić gałąź, co pozwala zachować zwięzłość logiki kategorii.

public class Main {
    enum Day { MON, TUE, WED, THU, FRI, SAT, SUN }
    public static void main(String[] args) {
        Day d = Day.SAT;
        String kind = switch (d) {
            case SAT, SUN -> "Rest";
            default -> "Work";
        };
        System.out.println(kind);
    }
}

Brak zduplikowanych etykiet

Każda etykieta może wystąpić tylko raz w całym switch. Umieszczenie tej samej wartości w dwóch gałęziach powoduje błąd kompilacji, ponieważ kompilator nie mógłby zdecydować, którą gałąź wykonać.

public class Main {
    public static void main(String[] args) {
        int n = 2;
        switch (n) {
            case 1, 2 -> System.out.println("Low");
            case 3, 4 -> System.out.println("High");
            default -> System.out.println("Other");
        }
    }
}

W porównaniu ze starym fall-through

W starym stylu z dwukropkiem grupowanie wymagało umieszczania pustych przypadków powodujących fall-through jeden nad drugim, nad wspólnym ciałem. Składnia z przecinkami jest znacznie czytelniejsza i zapobiega przypadkowemu przechodzeniu do kolejnych przypadków.

public class Main {
    public static void main(String[] args) {
        int code = 3;
        switch (code) {
            case 1, 3, 5, 7, 9 -> System.out.println("Odd");
            case 0, 2, 4, 6, 8 -> System.out.println("Even");
        }
    }
}

Grupowanie z blokami

Przypadek grupowany również może używać ciała blokowego. Dowolna pasująca etykieta uruchamia cały blok.

public class Main {
    public static void main(String[] args) {
        char grade = 'B';
        switch (grade) {
            case 'A', 'B' -> {
                System.out.println("Pass");
                System.out.println("Well done");
            }
            default -> System.out.println("Try again");
        }
    }
}

Łączenie z yield

Grupowane etykiety i yield dobrze współpracują, gdy współdzielona gałąź wymaga obliczeń.

public class Main {
    public static void main(String[] args) {
        int n = 4;
        int points = switch (n) {
            case 1, 2, 3 -> 10;
            case 4, 5, 6 -> {
                int bonus = n * 2;
                yield 20 + bonus;
            }
            default -> 0;
        };
        System.out.println(points);
    }
}

Korzyść dla czytelności

Przypadki z wieloma etykietami zastępują długie listy powtarzalnych gałęzi kilkoma przejrzystymi grupami, dzięki czemu ich przeznaczenie jest od razu widoczne.

public class Main {
    public static void main(String[] args) {
        int http = 204;
        String group = switch (http / 100) {
            case 1, 2, 3 -> "OK-ish";
            case 4, 5 -> "Error";
            default -> "Unknown";
        };
        System.out.println(group);
    }
}

Szybkie sprawdzenie

Jak sprawić, aby kilka wartości uruchamiało tę samą gałąź switch w nowoczesnej Javie?

Podsumowanie

Poznali Państwo przypadki z wieloma etykietami:

Wartości należy umieszczać po przecinku przed ->
Rozwiązanie działa dla typów int, char, String i enumów
Brak przypadkowego fall-through, w przeciwieństwie do starego stylu
Każda etykieta może wystąpić tylko raz
W razie potrzeby można łączyć je z blokami i yield

Często zadawane pytania

Czy lekcja „Przypadki z wieloma etykietami” jest bezpłatna?

Tak — pełny tekst „Przypadki z wieloma etykietami” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Java Academy, przejdź na CoddyKit PRO. Kurs Java Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Przypadki z wieloma etykietami”?

Grupuj kilka etykiet Ćwiczysz Java Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Java Academy?

Nie wymagamy żadnego doświadczenia. Java Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Przypadki z wieloma etykietami”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Java Academy?

Tak. Każda lekcja Java Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Java Academy