Java Academy · Aula

Declarando tipos selados

Restrinja quem pode estender um tipo.

Aula 1 de 413 etapas

Declarando tipos selados é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

O Que São Tipos Selados

Uma classe ou interface selada restringe quais outros tipos podem estendê-la ou implementá-la. Isso permite modelar um conjunto fechado de possibilidades que o compilador pode analisar.

O Problema Resolvido

Uma classe public normal pode ser estendida por qualquer pessoa, em qualquer lugar. Às vezes, você quer exatamente três formas ou dois tipos de pagamento, sem surpresas. A selagem torna essa intenção explícita e garante que ela seja respeitada.

A Palavra-Chave de Selagem

Marque um tipo como sealed e liste seus subtipos permitidos com permits. Cada subtipo permitido deve declarar seu próprio modificador de herança.

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

Modificadores de Subtipos

Cada subtipo permitido deve ser um destes: final (sem novas subclasses), sealed (continua a restrição) ou non-sealed (reabre a extensão livre). Registros são implicitamente final.

Uma Subclasse Final

Marcar uma subclasse como final encerra a hierarquia nesse 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);
    }
}

Uma Subclasse Sem Selagem

Um subtipo non-sealed reabre deliberadamente a extensão, permitindo que classes desconhecidas o estendam novamente. Use isso com moderação, quando um ramo precisar continuar aberto.

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

Classes Seladas Também

A selagem não se limita a interfaces. Uma classe abstract sealed class funciona da mesma maneira e pode conter estado e comportamento compartilhados.

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

Mesmo Módulo ou Pacote

Os subtipos permitidos devem estar no mesmo módulo que o tipo selado ou no mesmo pacote, se o código não for modular. Isso mantém o conjunto fechado unido e verificável.

Fiscalização pelo Compilador

Se uma classe tentar estender um tipo selado sem estar listada em permits, o código não será compilado. O conjunto fechado é garantido em tempo de compilação.

Por Que Isso Importa

Como o compilador conhece todos os subtipos, ele pode verificar se uma switch sobre o tipo selado trata todos os casos. Essa é a base da correspondência exaustiva de padrões, abordada em um curso posterior.

Uma Hierarquia Completa

Aqui está uma pequena hierarquia fechada usada como modelo de valor.

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ção Rápida

Teste sua compreensão sobre declarações seladas.

Responda na aula interativa

Recapitulação

Você aprendeu a declarar tipos selados.

sealed restringe quem pode estender ou implementar um tipo.
A cláusula permits lista os subtipos permitidos.
Cada subtipo deve ser final, sealed ou non-sealed.
Os subtipos ficam no mesmo módulo ou pacote, e isso é fiscalizado pelo compilador.

Grátis para começar

Aprenda Java com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 104
Aulas: 374

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Declarando tipos selados” é grátis?

Sim — o texto completo de “Declarando tipos selados” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Declarando tipos selados”?

Restrinja quem pode estender um tipo. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Declarando tipos selados”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Java Academy