Java Academy · Lezione

Dichiarare tipi sealed

Limitare chi può estendere un tipo

Dichiarare tipi sealed è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.

Cosa sono i tipi sealed

Una classe o un'interfaccia sealed limita i tipi che possono estenderla o implementarla. Questo consente di modellare un insieme chiuso di possibilità su cui il compilatore può ragionare.

Il problema che risolve

Una normale classe public può essere estesa da chiunque e in qualunque punto del codice. A volte si vogliono esattamente tre forme o due modalità di pagamento, senza sorprese. La dichiarazione sealed rende esplicita questa intenzione e la fa rispettare.

La parola chiave sealed

Si contrassegna un tipo come sealed e si elencano i sottotipi consentiti con permits. Ogni sottotipo consentito deve dichiarare il proprio modificatore di ereditarietà.

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

Modificatori dei sottotipi

Ogni sottotipo consentito deve essere uno tra: final (nessuna ulteriore sottoclasse), sealed (la restrizione continua) o non-sealed (l'estensione torna libera). I record sono implicitamente final.

Una sottoclasse final

Contrassegnare una sottoclasse come final chiude la gerarchia in quel ramo.

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

Una sottoclasse non-sealed

Un sottotipo non-sealed riapre deliberatamente l'estensione, consentendo nuovamente a classi non note di estenderlo. Lo si usa con parsimonia quando un ramo deve rimanere aperto.

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

Anche le classi sealed

La dichiarazione sealed non è limitata alle interfacce. Una sealed class astratta funziona allo stesso modo e può contenere stato e comportamento condivisi.

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

Stesso modulo o package

I sottotipi consentiti devono trovarsi nello stesso modulo del tipo sealed oppure nello stesso package, se il codice non è modulare. In questo modo l'insieme chiuso rimane unito e verificabile.

Controllo del compilatore

Se una classe prova a estendere un tipo sealed senza essere elencata in permits, il codice non viene compilato. L'insieme chiuso è garantito in fase di compilazione.

Perché è importante

Poiché il compilatore conosce ogni sottotipo, può verificare che uno switch sul tipo sealed gestisca tutti i casi. Questa è la base del pattern matching esaustivo, trattato in un corso successivo.

Una gerarchia completa

Ecco una piccola gerarchia chiusa usata come modello di valori.

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

Verifica rapida

Verifichi la Sua comprensione delle dichiarazioni sealed.

Riepilogo

Ha imparato a dichiarare tipi sealed.

sealed limita chi può estendere o implementare un tipo.
La clausola permits elenca i sottotipi consentiti.
Ogni sottotipo deve essere final, sealed o non-sealed.
I sottotipi si trovano nello stesso modulo o package e il compilatore ne impone il rispetto.

Domande Frequenti

La lezione «Dichiarare tipi sealed» è gratuita?

Sì — il testo completo di «Dichiarare tipi sealed» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.

Cosa imparerò in «Dichiarare tipi sealed»?

Limitare chi può estendere un tipo Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Dichiarare tipi sealed»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Java Academy