Java Academy · Lektion

Deklarera sealed-typer

Begränsa vilka som får utöka en typ.

Lektion 1 av 413 steg

Deklarera sealed-typer är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Java Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Java Academy innehåller totalt 4 lektioner.

Vad är sealed-typer

En sealed-klass eller ett sealed-gränssnitt begränsar vilka andra typer som får ärva från eller implementera den. Det gör att Ni kan modellera en sluten uppsättning möjligheter som kompilatorn kan dra slutsatser om.

Problemet som löses

En vanlig public-klass kan underklassas av vem som helst, var som helst. Ibland vill Ni ha exakt tre former eller två betalningstyper, utan överraskningar. Försegling gör avsikten tydlig och säkerställer den.

Nyckelordet sealed

Markera en typ som sealed och ange dess tillåtna undertyper med permits. Varje tillåten undertyp måste deklarera sin egen arvmodifierare.

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

Modifierare för undertyper

Varje tillåten undertyp måste vara en av följande: final (ingen ytterligare underklassning), sealed (begränsningen fortsätter) eller non-sealed (öppnar åter för fri utökning). Records är implicit final.

En final-underklass

Om en underklass markeras som final stängs hierarkin vid den 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-underklass

En non-sealed-undertyp öppnar medvetet för vidare arv och låter okända klasser ärva från den igen. Använd det sparsamt när en gren måste förbli öppen.

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

Även sealed-klasser

Försegling är inte begränsad till gränssnitt. En abstrakt sealed class fungerar på samma sätt och kan innehålla delat tillstånd och beteende.

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

Samma modul eller paket

Tillåtna undertyper måste finnas i samma modul som den förseglade typen, eller i samma paket om koden inte är modulär. Det håller den slutna uppsättningen samlad och möjlig att verifiera.

Kompilatorkontroll

Om en klass försöker ärva från en sealed-typ utan att vara listad i permits, kompileras koden inte. Den slutna uppsättningen garanteras vid kompilering.

Varför det är viktigt

Eftersom kompilatorn känner till varje undertyp kan den verifiera att en switch över den förseglade typen hanterar alla fall. Det är grunden för uttömmande mönstermatchning, som behandlas i en senare kurs.

En komplett hierarki

Här är en liten sluten hierarki som används som värdemodell.

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

Snabbtest

Testa er förståelse av sealed-deklarationer.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har lärt er att deklarera sealed-typer.

sealed begränsar vem som får ärva från eller implementera en typ.
Klausulen permits listar de tillåtna undertyperna.
Varje undertyp måste vara final, sealed eller non-sealed.
Undertyperna finns i samma modul eller paket och detta kontrolleras av kompilatorn.

Gratis att börja

Lär dig Java med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 104
Lektioner: 374

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Deklarera sealed-typer” gratis?

Ja – hela texten till ”Deklarera sealed-typer” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Java Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Java Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Deklarera sealed-typer”?

Begränsa vilka som får utöka en typ. Ni övar på Java Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Java Academy?

Du behöver inga förkunskaper. Utbildningen i Java Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Deklarera sealed-typer”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Java Academy-lektionen?

Ja. Varje Java Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Java Academy