Java Academy · leksjon

Deklarere sealed-typer

Begrens hvem som kan utvide en type

Leksjon 1 av 413 trinn

Deklarere sealed-typer er en gratis leksjon i Java Academy på CoddyKit. Dette er leksjon 1 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Java Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Java Academy inneholder totalt 4 leksjoner.

Hva er sealed-typer

En sealed-klasse eller et grensesnitt begrenser hvilke andre typer som kan arve fra eller implementere den. Dette lar deg modellere et lukket sett med muligheter som kompilatoren kan analysere.

Problemet sealed løser

En vanlig public-klasse kan arves fra av hvem som helst, hvor som helst. Noen ganger vil du ha nøyaktig tre former eller to betalingstyper, uten uventede varianter. sealed gjør denne hensikten tydelig og håndhever den.

Nøkkelordet sealed

Merk en type som sealed, og oppgi de tillatte undertypene med permits. Hver tillatte undertype må deklarere sin egen arvemodifikator.

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

Modifikatorer for undertyper

Hver tillatte undertype må være én av følgende: final (ingen videre underklassing), sealed (fortsetter begrensningen) eller non-sealed (åpner for fri utvidelse). Records er implisitt final.

En final-underklasse

Når en underklasse merkes med final, lukkes hierarkiet ved denne grenen.

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

En non-sealed-underklasse

En undertype med non-sealed åpner med hensikt for videre utvidelse, slik at ukjente klasser igjen kan arve fra den. Bruk dette sparsomt når én gren må forbli åpen.

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

Også sealed-klasser

sealed er ikke begrenset til grensesnitt. En abstrakt sealed class fungerer på samme måte og kan inneholde delt tilstand og atferd.

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

Samme modul eller pakke

Tillatte undertyper må ligge i samme modul som sealed-typen, eller i samme pakke hvis koden ikke er modulbasert. Dette holder det lukkede settet samlet og mulig å verifisere.

Kompilatorens håndheving

Hvis en klasse prøver å arve fra en sealed-type uten å være oppført i permits, kompileres ikke koden. Det lukkede settet garanteres ved kompilering.

Hvorfor dette er viktig

Fordi kompilatoren kjenner alle undertypene, kan den kontrollere at en switch over sealed-typen håndterer alle tilfeller. Dette er grunnlaget for uttømmende pattern matching, som dekkes i et senere kurs.

Et komplett hierarki

Her er et lite, lukket hierarki som brukes som en verdimodell.

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

Kunnskapssjekk

Test forståelsen din av sealed-deklarasjoner.

Besvar den i den interaktive leksjonen

Oppsummering

Du har lært å deklarere sealed-typer.

sealed begrenser hvem som kan arve fra eller implementere en type.
permits-leddet lister opp tillatte undertyper.
Hver undertype må være final, sealed eller non-sealed.
Undertyper ligger i samme modul eller pakke, og dette håndheves av kompilatoren.

Gratis å komme i gang

Lær deg Java med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 104
Leksjoner: 374

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Deklarere sealed-typer» gratis?

Ja – hele teksten i «Deklarere sealed-typer» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Java Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Java Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Deklarere sealed-typer»?

Begrens hvem som kan utvide en type Du øver på Java Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Java Academy?

Ingen tidligere erfaring er nødvendig. Java Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.

Hvor lang tid tar leksjonen «Deklarere sealed-typer»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Java Academy-leksjonen?

Ja. Alle Java Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Java Academy