Java Academy · Lekcja

Deklarowanie typów sealed

Ograniczanie typów, które mogą dziedziczyć

Deklarowanie typów sealed 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.

Czym są typy sealed

Klasa lub interfejs sealed ogranicza listę innych typów, które mogą po nim dziedziczyć lub go implementować. Dzięki temu można modelować zamknięty zbiór możliwości, który kompilator może analizować.

Jaki problem rozwiązują

Zwykła klasa public może być rozszerzana przez każdego i w dowolnym miejscu. Czasami potrzebne są dokładnie trzy kształty albo dwa rodzaje płatności, bez nieprzewidzianych przypadków. Sealing wyraża ten zamiar wprost i wymusza jego przestrzeganie.

Słowo kluczowe sealed

Oznacz typ jako sealed i wymień jego dozwolone podtypy za pomocą permits. Każdy dozwolony podtyp musi zadeklarować własny modyfikator dziedziczenia.

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

    public static void main(String[] args) {
        Shape s = new Circle(2.0);
        System.out.println(s);
    }
}

Modyfikatory podtypów

Każdy dozwolony podtyp musi być jednym z następujących typów: final (bez dalszego dziedziczenia), sealed (kontynuuje ograniczenie) lub non-sealed (ponownie otwiera możliwość swobodnego rozszerzania). Rekordy są niejawnie final.

Podklasa final

Oznaczenie podklasy jako final zamyka hierarchię w tej gałęzi.

public class Main {
    sealed interface Animal permits Dog, Cat {}
    static final class Dog implements Animal {
        public String toString() { return "Dog"; }
    }
    static final class Cat implements Animal {
        public String toString() { return "Cat"; }
    }

    public static void main(String[] args) {
        Animal a = new Dog();
        System.out.println(a);
    }
}

Podklasa non-sealed

Podtyp non-sealed celowo ponownie otwiera możliwość dziedziczenia, pozwalając nieznanym klasom znowu po nim dziedziczyć. Używaj go oszczędnie, gdy jedna gałąź musi pozostać otwarta.

public class Main {
    sealed interface Plugin permits CorePlugin, ExternalPlugin {}
    static final class CorePlugin implements Plugin {}
    static non-sealed class ExternalPlugin implements Plugin {}
    static class ThirdParty extends ExternalPlugin {}

    public static void main(String[] args) {
        Plugin p = new ThirdParty();
        System.out.println(p.getClass().getSimpleName());
    }
}

Klasy sealed również

Sealing nie ogranicza się do interfejsów. Abstrakcyjna sealed class działa tak samo i może przechowywać współdzielony stan oraz zachowanie.

public class Main {
    sealed static abstract class Expr permits Num, Add {}
    static final class Num extends Expr {
        final int value;
        Num(int value) { this.value = value; }
    }
    static final class Add extends Expr {
        final Expr left, right;
        Add(Expr left, Expr right) { this.left = left; this.right = right; }
    }

    public static void main(String[] args) {
        Expr e = new Add(new Num(1), new Num(2));
        System.out.println(e.getClass().getSimpleName());
    }
}

Ten sam moduł lub pakiet

Dozwolone podtypy muszą znajdować się w tym samym module co typ sealed albo w tym samym pakiecie, jeśli kod nie jest modularny. Dzięki temu zamknięty zbiór pozostaje spójny i możliwy do zweryfikowania.

Wymuszanie przez kompilator

Jeśli klasa próbuje rozszerzyć typ sealed, ale nie została wymieniona w permits, kod nie kompiluje się. Zamknięty zbiór jest gwarantowany w czasie kompilacji.

Dlaczego ma to znaczenie

Ponieważ kompilator zna każdy podtyp, może sprawdzić, czy instrukcja switch dla typu sealed obsługuje wszystkie przypadki. To podstawa wyczerpującego dopasowywania wzorców, które omówimy w późniejszym kursie.

Kompletna hierarchia

Oto niewielka zamknięta hierarchia używana jako model wartości.

public class Main {
    sealed interface Json permits JsonNull, JsonNumber, JsonString {}
    record JsonNull() implements Json {}
    record JsonNumber(double value) implements Json {}
    record JsonString(String value) implements Json {}

    public static void main(String[] args) {
        Json[] values = { new JsonNull(), new JsonNumber(3.5), new JsonString("hi") };
        for (Json j : values) {
            System.out.println(j);
        }
    }
}

Szybki test

Sprawdź swoją wiedzę na temat deklaracji sealed.

Podsumowanie

Zapoznałeś się z deklarowaniem typów sealed.

sealed ogranicza to, kto może rozszerzać typ lub go implementować.
Klauzula permits wymienia dozwolone podtypy.
Każdy podtyp musi być final, sealed albo non-sealed.
Podtypy znajdują się w tym samym module lub pakiecie, a kompilator wymusza przestrzeganie tych zasad.

Często zadawane pytania

Czy lekcja „Deklarowanie typów sealed” jest bezpłatna?

Tak — pełny tekst „Deklarowanie typów sealed” 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 „Deklarowanie typów sealed”?

Ograniczanie typów, które mogą dziedziczyć Ć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 „Deklarowanie typów sealed”?

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