Java Academy · Lekcja

Wzorce w switch

Łączenie typów sealed i wzorców

Wzorce w switch 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.

Wzorce w switch

Switch rozwinął się od dopasowywania stałych do dopasowywania wzorców. W połączeniu z typami sealed i rekordami switch może wybierać obsługę na podstawie typu, przeprowadzać destrukturyzację danych i gwarantować kompletność przypadków.

Wzorce typów w switch

Każda gałąź case może zawierać wzorzec typu, przypisujący zmienną o określonym typie na potrzeby danej gałęzi.

public class Main {
    static String kind(Object o) {
        return switch (o) {
            case Integer i -> "int " + i;
            case String s -> "string " + s;
            default -> "other";
        };
    }

    public static void main(String[] args) {
        System.out.println(kind(42));
        System.out.println(kind("hi"));
        System.out.println(kind(3.14));
    }
}

Typy sealed nie wymagają default

Gdy selektor ma typ sealed i uwzględniono wszystkie dozwolone podtypy, switch jest wyczerpujący bez użycia default.

public class Main {
    sealed interface Shape permits Circle, Square {}
    record Circle(double r) implements Shape {}
    record Square(double s) implements Shape {}

    static double area(Shape shape) {
        return switch (shape) {
            case Circle c -> Math.PI * c.r() * c.r();
            case Square sq -> sq.s() * sq.s();
        };
    }

    public static void main(String[] args) {
        System.out.printf("%.2f%n", area(new Square(3)));
    }
}

Wzorce rekordów w gałęziach case

Gałęzie case mogą przeprowadzać destrukturyzację rekordów, udostępniając ich składowe bezpośrednio w treści gałęzi.

public class Main {
    sealed interface Shape permits Circle, Rectangle {}
    record Circle(double r) implements Shape {}
    record Rectangle(double w, double h) implements Shape {}

    static double area(Shape shape) {
        return switch (shape) {
            case Circle(double r) -> Math.PI * r * r;
            case Rectangle(double w, double h) -> w * h;
        };
    }

    public static void main(String[] args) {
        System.out.printf("%.2f%n", area(new Rectangle(2, 5)));
    }
}

Warunki when

Klauzula when dodaje warunek logiczny do gałęzi case. Gałąź pasuje tylko wtedy, gdy wzorzec pasuje i warunek ma wartość true.

public class Main {
    static String size(Object o) {
        return switch (o) {
            case Integer i when i < 0 -> "negative";
            case Integer i when i == 0 -> "zero";
            case Integer i -> "positive";
            default -> "not an int";
        };
    }

    public static void main(String[] args) {
        System.out.println(size(-5));
        System.out.println(size(0));
        System.out.println(size(7));
    }
}

Kolejność ma znaczenie przy warunkach

Gałęzie case z warunkami są sprawdzane od góry do dołu. Bardziej szczegółowa gałąź z warunkiem musi znajdować się przed szerszą gałęzią bez warunku, w przeciwnym razie szersza gałąź ją przechwyci.

Obsługa null

Proszę dodać case null, aby obsłużyć selektor o wartości null; w przeciwnym razie switch zgłosi NullPointerException. Można nawet połączyć go jako case null, default.

public class Main {
    static String label(String s) {
        return switch (s) {
            case null -> "missing";
            case "yes" -> "affirmative";
            default -> "other: " + s;
        };
    }

    public static void main(String[] args) {
        System.out.println(label(null));
        System.out.println(label("yes"));
        System.out.println(label("maybe"));
    }
}

Zagnieżdżone wzorce w switch

Gałęzie case mogą zagnieżdżać wzorce rekordów, aby dopasowywać głębokie struktury i sprawdzać warunki dotyczące wartości wewnętrznych w jednym miejscu.

public class Main {
    record Point(int x, int y) {}
    record Line(Point a, Point b) {}

    static String describe(Object o) {
        return switch (o) {
            case Line(Point(var x1, var y1), Point(var x2, var y2)) when x1 == x2 -> "vertical";
            case Line(Point a, Point b) -> "line";
            default -> "other";
        };
    }

    public static void main(String[] args) {
        System.out.println(describe(new Line(new Point(1, 0), new Point(1, 5))));
        System.out.println(describe(new Line(new Point(0, 0), new Point(2, 3))));
    }
}

Instrukcje i wyrażenia

Switch z wzorcami działa zarówno jako wyrażenie (zwracające wartość za pomocą -> lub yield), jak i jako instrukcja. Zasady kompletności mają zastosowanie, gdy selektor jest typu sealed.

Zastępowanie kodu Visitor

Połączenie typów sealed i switch z wzorcami zastępuje rozwlekłe wzorce Visitor oraz ciągi instanceof zwięzłym, sprawdzanym przez kompilator wyborem obsługi w ramach zamkniętego modelu.

Kompletny interpreter

Interpreter wyrażeń korzystający z zamkniętego modelu i switch z wzorcami.

public class Main {
    sealed interface Expr permits Num, Add, Mul {}
    record Num(int value) implements Expr {}
    record Add(Expr left, Expr right) implements Expr {}
    record Mul(Expr left, Expr right) implements Expr {}

    static int eval(Expr e) {
        return switch (e) {
            case Num(int v) -> v;
            case Add(Expr l, Expr r) -> eval(l) + eval(r);
            case Mul(Expr l, Expr r) -> eval(l) * eval(r);
        };
    }

    public static void main(String[] args) {
        Expr e = new Add(new Num(2), new Mul(new Num(3), new Num(4)));
        System.out.println(eval(e));
    }
}

Szybkie sprawdzenie

Proszę sprawdzić swoje rozumienie wzorców w switch.

Podsumowanie

Poznał(a) Pan/Pani wzorce w switch.

Gałęzie case mogą zawierać wzorce typów i wzorce rekordów wraz z destrukturyzacją.
Selektory typu sealed zapewniają wyczerpujące instrukcje switch bez default.
Warunki when uszczegóławiają gałęzie case; kolejność ma znaczenie.
case null bezpiecznie obsługuje wartość null.

Często zadawane pytania

Czy lekcja „Wzorce w switch” jest bezpłatna?

Tak — pełny tekst „Wzorce w switch” 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 „Wzorce w switch”?

Łączenie typów sealed i wzorców Ć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 „Wzorce w switch”?

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