Java Academy · Aula

Tipos selados com registros

Modele hierarquias fechadas.

Tipos selados com registros é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 3 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.

Selagem e Registros

Interfaces seladas e registros formam uma combinação perfeita. A interface selada define um conjunto fechado de casos; cada registro é um caso concreto e imutável. Juntos, eles modelam tipos de dados algébricos.

Registros São Implicitamente Finais

Um registro é automaticamente final, portanto satisfaz a regra de que os subtipos permitidos devem ser finais, selados ou sem selagem. Nenhum modificador adicional é necessário.

Uma Hierarquia Fechada de Formas

Modele formas como registros que implementam uma interface selada, cada um contendo seus próprios dados.

public class Main {
    sealed interface Shape permits Circle, Rectangle {}
    record Circle(double radius) implements Shape {}
    record Rectangle(double width, double height) implements Shape {}

    public static void main(String[] args) {
        Shape s = new Rectangle(3, 4);
        System.out.println(s);
    }
}

Adicionando Comportamento

A interface selada pode declarar métodos que todos os registros implementam, oferecendo polimorfismo sobre o conjunto fechado.

public class Main {
    sealed interface Shape permits Circle, Rectangle {
        double area();
    }
    record Circle(double radius) implements Shape {
        public double area() { return Math.PI * radius * radius; }
    }
    record Rectangle(double width, double height) implements Shape {
        public double area() { return width * height; }
    }

    public static void main(String[] args) {
        Shape s = new Circle(2);
        System.out.printf("Area: %.2f%n", s.area());
    }
}

Igualdade e toString Automáticos

Os registros geram equals, hashCode e toString automaticamente. Dois registros com os mesmos componentes são iguais, o que é ideal para modelar valores.

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

    public static void main(String[] args) {
        Circle a = new Circle(5);
        Circle b = new Circle(5);
        System.out.println(a.equals(b));
        System.out.println(a);
    }
}

Modelando Resultados

Um padrão comum é um tipo de resultado selado com um registro de sucesso e um registro de falha, substituindo retornos nulos ou exceções por resultados esperados.

public class Main {
    sealed interface Result permits Ok, Err {}
    record Ok(int value) implements Result {}
    record Err(String message) implements Result {}

    static Result parse(String s) {
        try { return new Ok(Integer.parseInt(s)); }
        catch (NumberFormatException e) { return new Err("bad number: " + s); }
    }

    public static void main(String[] args) {
        System.out.println(parse("42"));
        System.out.println(parse("oops"));
    }
}

Construtores Compactos para Validação

Os registros podem validar suas entradas em um construtor compacto, mantendo cada caso correto por construção.

public class Main {
    sealed interface Shape permits Circle {}
    record Circle(double radius) implements Shape {
        Circle {
            if (radius < 0) throw new IllegalArgumentException("radius must be >= 0");
        }
    }

    public static void main(String[] args) {
        try { new Circle(-1); }
        catch (IllegalArgumentException e) { System.out.println(e.getMessage()); }
    }
}

Modelos de Dados Recursivos

Como um registro pode referenciar a interface selada, você pode criar estruturas recursivas, como árvores de expressões ou listas encadeadas.

public class Main {
    sealed interface Expr permits Num, Add {}
    record Num(int value) implements Expr {}
    record Add(Expr left, Expr right) implements Expr {}

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

Vantagens da Imutabilidade

Os registros são imutáveis superficialmente, portanto uma hierarquia selada de registros é fácil de analisar, segura para compartilhar e adequada à concorrência. Não é necessária uma cópia defensiva dos próprios registros.

Combinando com a Seleção

Registros selados funcionam muito bem com a switch de correspondência de padrões: cada caso pode desconstruir um registro, e o compilador verifica se todos os casos foram abrangidos. Isso é explorado no curso de padrões.

Um Cálculo sobre o Modelo

Você pode escrever um interpretador como um método que percorre a árvore recursiva de registros.

public class Main {
    sealed interface Expr permits Num, Add {}
    record Num(int value) implements Expr {}
    record Add(Expr left, Expr right) implements Expr {}

    static int eval(Expr e) {
        if (e instanceof Num n) return n.value();
        Add a = (Add) e;
        return eval(a.left()) + eval(a.right());
    }

    public static void main(String[] args) {
        Expr e = new Add(new Num(4), new Add(new Num(5), new Num(6)));
        System.out.println(eval(e));
    }
}

Verificação Rápida

Teste sua compreensão sobre registros selados.

Recapitulação

Você aprendeu a combinar tipos selados com registros.

Os registros são implicitamente finais, portanto se encaixam como subtipos permitidos.
A interface selada pode declarar métodos compartilhados.
Os registros fornecem igualdade, cálculo de valores de dispersão e toString automaticamente.
Juntos, eles modelam dados fechados, imutáveis e possivelmente recursivos.

Perguntas Frequentes

A aula “Tipos selados com registros” é grátis?

Sim — o texto completo de “Tipos selados com registros” é 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 “Tipos selados com registros”?

Modele hierarquias fechadas. 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 3 de 4.

Quanto tempo leva a aula “Tipos selados com registros”?

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