Java Academy · Lekcja

switch jako wyrażenie

Zwracaj wartości z switch

switch jako wyrażenie to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 2 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.

Instrukcje a wyrażenia

Instrukcja wykonuje działanie. Wyrażenie zwraca wartość. Nowoczesna Java pozwala używać switch jako wyrażenia, dzięki czemu wynik można bezpośrednio przypisać do zmiennej.

Przypisywanie wyniku switch

Gdy switch występuje po prawej stronie znaku =, każda gałąź dostarcza wartość. Forma strzałkowa automatycznie zwraca wartość znajdującą się po ->.

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

Średnik po bloku

Ponieważ wyrażenie switch jest częścią instrukcji, po zamykającym nawiasie klamrowym należy umieścić średnik. Jego pominięcie jest częstym błędem kompilacji.

public class Main {
    public static void main(String[] args) {
        int n = 2;
        int doubled = switch (n) {
            case 1 -> 2;
            case 2 -> 4;
            default -> 0;
        };
        System.out.println(doubled);
    }
}

Kompletność

Wyrażenie switch musi obejmować każdą możliwą wartość. W przypadku większości typów oznacza to konieczność uwzględnienia gałęzi default; w przeciwnym razie kod się nie skompiluje.

public class Main {
    public static void main(String[] args) {
        int score = 85;
        char grade = switch (score / 10) {
            case 10, 9 -> 'A';
            case 8 -> 'B';
            case 7 -> 'C';
            default -> 'F';
        };
        System.out.println(grade);
    }
}

Enumy nie wymagają default

Gdy instrukcja switch działa na typie enum i obejmuje wszystkie stałe, kompilator wie, że jest kompletna. Gałąź default staje się opcjonalna.

public class Main {
    enum Dir { NORTH, SOUTH, EAST, WEST }
    public static void main(String[] args) {
        Dir d = Dir.EAST;
        String label = switch (d) {
            case NORTH -> "Up";
            case SOUTH -> "Down";
            case EAST -> "Right";
            case WEST -> "Left";
        };
        System.out.println(label);
    }
}

Bezpośrednie zwracanie

Metoda może bezpośrednio zwracać wyrażenie switch za pomocą return, co pozwala tworzyć zwięzłe metody wyszukujące.

public class Main {
    static int sides(String shape) {
        return switch (shape) {
            case "triangle" -> 3;
            case "square" -> 4;
            case "pentagon" -> 5;
            default -> 0;
        };
    }
    public static void main(String[] args) {
        System.out.println(sides("square"));
    }
}

Wyniki liczbowe

Gałęzie mogą zwracać liczby, wykonywać obliczenia lub wywoływać metody. Każda gałąź musi dostarczać wartość tego samego typu co przypisywana zmienna.

public class Main {
    public static void main(String[] args) {
        int month = 2;
        int days = switch (month) {
            case 2 -> 28;
            case 4, 6, 9, 11 -> 30;
            default -> 31;
        };
        System.out.println("Days: " + days);
    }
}

Użycie wyniku w miejscu wywołania

Wartości z wyrażenia switch można użyć od razu, na przykład wewnątrz wywołania println.

public class Main {
    public static void main(String[] args) {
        int code = 1;
        System.out.println("Status: " + switch (code) {
            case 0 -> "OK";
            case 1 -> "Warning";
            default -> "Error";
        });
    }
}

Spójność typów

Wszystkie gałęzie muszą zwracać ten sam typ wyniku. Jeśli jedna gałąź zwraca int, a inna String, kod się nie skompiluje. Należy zachować spójność gałęzi.

public class Main {
    public static void main(String[] args) {
        int n = 3;
        double factor = switch (n) {
            case 1 -> 0.5;
            case 2 -> 1.0;
            default -> 1.5;
        };
        System.out.println(factor);
    }
}

Zastępowanie łańcuchów operatorów trójargumentowych

Wyrażenie switch często jest czytelniejsze niż zagnieżdżone operatory trójargumentowe, gdy jedna wartość jest mapowana na wiele wyników.

public class Main {
    public static void main(String[] args) {
        int rating = 4;
        String stars = switch (rating) {
            case 1 -> "*";
            case 2 -> "**";
            case 3 -> "***";
            case 4 -> "****";
            default -> "*****";
        };
        System.out.println(stars);
    }
}

Łączenie ze zmiennymi

Wyniku wyrażenia switch można używać w kolejnych obliczeniach, tak jak każdej innej wartości.

public class Main {
    public static void main(String[] args) {
        int tier = 2;
        int discount = switch (tier) {
            case 1 -> 5;
            case 2 -> 10;
            default -> 0;
        };
        int price = 100 - discount;
        System.out.println("Price: " + price);
    }
}

Szybkie sprawdzenie

Dlaczego wyrażenie switch zazwyczaj musi zawierać gałąź default?

Podsumowanie

Poznali Państwo użycie switch jako wyrażenia:

Zwraca wartość, którą można przypisać lub zwrócić
Przypisanie należy zakończyć średnikiem
Musi być kompletne (zwykle wymaga default)
Enumy obejmujące wszystkie stałe nie wymagają default
Wszystkie gałęzie muszą mieć ten sam typ wyniku

Często zadawane pytania

Czy lekcja „switch jako wyrażenie” jest bezpłatna?

Tak — pełny tekst „switch jako wyrażenie” 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 „switch jako wyrażenie”?

Zwracaj wartości z switch Ć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 2 z 4.

Ile czasu zajmuje lekcja „switch jako wyrażenie”?

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