Java Academy · Lekcja

Składnia switch ze strzałką

Używaj nowoczesnej składni switch ze strzałką

Składnia switch ze strzałką to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 1 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.

Problem ze starym poleceniem switch

Klasyczna instrukcja Java switch używała etykiet zakończonych dwukropkiem i wymagała umieszczenia break po każdym przypadku. Pominięcie break powodowało błędy typu fall-through, w których wykonanie przechodziło do następnego przypadku.

Nowoczesna Java (14+) wprowadza składnię strzałkową arrow syntax, która całkowicie rozwiązuje ten problem.

Podstawy składni strzałkowej

W przypadku strzałkowej instrukcji switch każda etykieta używa -> zamiast :. Nie występuje fall-through i nie trzeba używać break. Każda gałąź wykonuje wyłącznie własny kod.

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

Koniec z break

W starym stylu trzeba było zapisywać break; po każdym przypadku. Forma strzałkowa całkowicie usuwa ten obowiązek. Wykonywana jest tylko pasująca gałąź.

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

Ciała bloków

Jeśli gałąź wymaga więcej niż jednej instrukcji, należy ująć ją w nawiasy klamrowe { }. Blok może zawierać dowolną liczbę instrukcji.

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

switch dla napisów

Strzałkowa instrukcja switch działa z wartościami String tak samo jak stary styl. Porównania wewnętrznie używają metody equals, dlatego rozróżniana jest wielkość liter.

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

Gałąź default

Gałąź default obsługuje każdą wartość, której nie obejmują pozostałe przypadki. Dobrą praktyką jest zawsze ją uwzględniać, aby nieoczekiwane dane wejściowe były obsługiwane w kontrolowany sposób.

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

switch dla enumów

Strzałkowa instrukcja switch doskonale współpracuje z typami enum. Nazwę enuma można pominąć w każdej etykiecie, dzięki czemu gałęzie pozostają krótkie i czytelne.

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

Wywoływanie metod w gałęziach

Każda gałąź strzałkowa może wywoływać dowolną metodę. Dzięki temu kod switch pozostaje czytelny, a właściwe działania są delegowane w inne miejsce.

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

Czytelniej niż if-else

Strzałkowa instrukcja switch często zastępuje długie łańcuchy if-else. Gdy porównywana jest jedna zmienna z wieloma stałymi wartościami, switch jest czytelniejszy.

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

Tylko działania uboczne

Instrukcja switch (w używanej tutaj formie strzałkowej) wykonuje działania, ale nie zwraca wartości. Aby zwrócić wartość, należy użyć wyrażenia switch, omówionego w następnej lekcji.

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

Wiele wartości, jedna gałąź

Kilka wartości może współdzielić jedną gałąź, jeśli zostaną rozdzielone przecinkami. Jest to zapowiedź przypadków z wieloma etykietami, które zostaną omówione później.

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

Szybkie sprawdzenie

Jaka jest główna zaleta strzałkowej formy switch w porównaniu ze starym stylem opartym na dwukropkach?

Podsumowanie

Poznali Państwo nowoczesną strzałkową składnię switch:

Należy używać -> zamiast :
Brak fall-through i brak konieczności używania break
Należy używać nawiasów klamrowych { } dla gałęzi zawierających wiele instrukcji
Etykiety należy rozdzielać przecinkami, aby współdzielić gałąź
Należy zawsze uwzględniać gałąź default

Często zadawane pytania

Czy lekcja „Składnia switch ze strzałką” jest bezpłatna?

Tak — pełny tekst „Składnia switch ze strzałką” 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 „Składnia switch ze strzałką”?

Używaj nowoczesnej składni switch ze strzałką Ć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 1 z 4.

Ile czasu zajmuje lekcja „Składnia switch ze strzałką”?

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