Padrões de registros
Desestruture registros em padrões.
Padrões de registros é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 2 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.
Padrões de registro
Um padrão de registro corresponde a um registro e o desestrutura, vinculando seus componentes a variáveis em uma única etapa. Não é mais necessário chamar cada acessador manualmente.
Um registro para desestruturar
Comece com um registro simples. Seus componentes são aquilo que um padrão pode extrair.
public class Main {
record Point(int x, int y) {}
public static void main(String[] args) {
Point p = new Point(3, 4);
System.out.println(p.x() + ", " + p.y());
}
}Desestruturação com teste de tipo
Em vez de instanceof Point p e depois p.x(), escreva instanceof Point(int x, int y) para vincular x e y diretamente.
public class Main {
record Point(int x, int y) {}
public static void main(String[] args) {
Object obj = new Point(3, 4);
if (obj instanceof Point(int x, int y)) {
System.out.println("Sum: " + (x + y));
}
}
}Componentes tornam-se variáveis locais
Os nomes dentro do padrão (x, y) são novas variáveis locais que contêm os valores dos componentes do registro. Você escolhe os nomes; eles não precisam corresponder aos do registro.
public class Main {
record Point(int x, int y) {}
public static void main(String[] args) {
Object obj = new Point(10, 20);
if (obj instanceof Point(int a, int b)) {
System.out.println("a=" + a + " b=" + b);
}
}
}Usando inferência de tipo nos padrões
Você pode escrever var para um componente e deixar o compilador inferir seu tipo, o que é útil quando os tipos são longos.
public class Main {
record Pair(String key, Integer value) {}
public static void main(String[] args) {
Object obj = new Pair("age", 30);
if (obj instanceof Pair(var key, var value)) {
System.out.println(key + " = " + value);
}
}
}Padrões na seleção
Os padrões de registro também funcionam em seleções, fazendo com que os casos sejam lidos como formas de dados.
public class Main {
record Point(int x, int y) {}
static String classify(Object obj) {
return switch (obj) {
case Point(int x, int y) when x == y -> "on diagonal";
case Point(int x, int y) -> "at " + x + "," + y;
default -> "not a point";
};
}
public static void main(String[] args) {
System.out.println(classify(new Point(5, 5)));
System.out.println(classify(new Point(1, 2)));
}
}Correspondência com inferência de tipo
Os tipos dos componentes no padrão precisam ser compatíveis com os tipos declarados no registro. Usar o tipo exato ou var é a opção segura.
Combinando com guardas
Adicione uma guarda when depois de um padrão de registro para corresponder somente quando os valores desestruturados satisfizerem uma condição.
public class Main {
record Temperature(double celsius) {}
static String alert(Object o) {
if (o instanceof Temperature(double c) && c > 38.0) {
return "fever: " + c;
}
return "normal";
}
public static void main(String[] args) {
System.out.println(alert(new Temperature(39.5)));
System.out.println(alert(new Temperature(36.6)));
}
}Acesso mais limpo aos dados
Os padrões de registro são especialmente úteis quando você precisa apenas de alguns campos. Eles eliminam uma cadeia de chamadas de acessadores e tornam os dados relevantes óbvios no ponto da correspondência.
Valores nulos e padrões de registro
Como todos os padrões instanceof, um padrão de registro é falso para valores nulos. A desestruturação só acontece depois que se confirma que o valor é uma instância não nula do registro.
Exemplo prático
Desestruture para calcular um valor diretamente a partir dos componentes.
public class Main {
record Rectangle(int width, int height) {}
static int area(Object o) {
if (o instanceof Rectangle(int w, int h)) {
return w * h;
}
return 0;
}
public static void main(String[] args) {
System.out.println(area(new Rectangle(4, 5)));
System.out.println(area("not a rect"));
}
}Verificação rápida
Teste sua compreensão dos padrões de registro.
Recapitulação
Você aprendeu os padrões de registro.
- Eles testam um tipo de registro e desestruturam seus componentes ao mesmo tempo.
- Os nomes dos componentes são novas variáveis locais escolhidas por você;
varinfere os tipos. - Eles funcionam tanto em
instanceofquanto emswitch. - Como todos os padrões, eles são falsos para valores nulos.
Perguntas Frequentes
A aula “Padrões de registros” é grátis?
Sim — o texto completo de “Padrões de 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 “Padrões de registros”?
Desestruture registros em padrões. 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 2 de 4.
Quanto tempo leva a aula “Padrões de 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
- Correspondência de padrões para instanceof
- Padrões de registros
- Padrões de registros aninhados
- Padrões em switch