Os padrões de registro Java foram introduzidos no Java 16 como parte do Projeto Amber e são aprimorados no Java 21 com a adição de desconstrutores e correspondência de padrões. Este recurso permite uma maneira mais concisa e flexível de lidar com dados em aplicativos Java. Neste tutorial, abordaremos o conceito de padrões de registro, como eles ajudam na correspondência de padrões e vários exemplos de codificação.

1. Recapitulação rápida dos registros Java
Antes de mergulhar nos padrões de registro, vamos recapitular rapidamente os registros Java. Os registros foram introduzidos no Java 14 como um novo tipo de classe projetada especificamente para armazenar dados imutáveis. Eles eliminam a necessidade de escrever código clichê, fornecendo uma sintaxe mais concisa para definir classes com dados. No exemplo a seguir, definimos um registro denominado "Pessoa" com três campos: nome, sobrenome e idade.

registro Pessoa(String primeiroNome, String sobrenome, int idade) {}

Os registros, por serem imutáveis, restringem certas características:

• Todos os campos são finais
• A classe é implicitamente final
• É proibida a declaração de campos de instância

Os registros geram automaticamente um construtor e métodos getter para cada campo, tornando-os mais adequados para suportes de dados do que classes tradicionais.

2. O que são padrões de registro?
Os padrões de registro, introduzidos no Java 21, combinam o conceito de padrões com registros que permitem desconstruir e extrair valores dos registros facilmente. Um padrão de registro consiste em um tipo de classe de registro e variáveis ​​de padrão opcionais às quais são atribuídos valores extraídos do registro de destino somente se o teste for bem-sucedido.

O valor nulo não corresponde a nenhum padrão de registro, portanto as variáveis ​​do padrão não serão inicializadas neste caso.

3. Destruidores de registros
Um destruidor é o inverso de um construtor. Extrai valores de um objeto em vez de adicioná-los. No contexto dos registros, um destruidor é chamado de “desconstrutor”. Permite decompor valores de registro em seus componentes individuais. Suponha que temos um registro chamado "Nome" com os seguintes campos:

registro Cliente(String primeiroNome, String sobrenome, int idade) {}

Podemos usar um desconstrutor para extrair os valores desses campos de uma instância do registro "Cliente", conforme mostrado no exemplo a seguir:

Cliente cliente = novo Cliente("Jane", "Smith", 30);

if (instância do cliente do Cliente (String firstName, String lastName, int age)) {
System.out.println("Nome: "primeiroNome); // Jane
System.out.println("Sobrenome: "sobrenome); //Smith
System.out.println("Idade: "idade); //30
}

As estruturas de registro podem ser úteis em situações em que precisamos armazenar e recuperar vários valores relacionados como um único objeto. O recurso de desconstrução de registros nos permite extrair e usar facilmente esses valores em nosso código.

4. Registrar padrões em instruções de switch
Java 16 introduziu correspondência de padrões para instruções instanceof, que foi expandida ainda mais em Java 21 para incluir instruções switch. Ele permite um código mais conciso e legível ao lidar com vários padrões.

Digamos que temos um registro chamado "Conta" com três subtipos: "SavingAccount", "CreditCardAccount" e "HomeLoanAccount". Cada subtipo possui uma forma diferente de calcular seu saldo. Podemos usar o padrão de registro em uma instrução switch para lidar com esses três casos, conforme mostrado abaixo:

conta de interface {}
registro SavingAccount (saldo duplo) implementa conta {}
registrar CreditCardAccount(double creditLimit, double used) implementa Account {}
registro HomeLoanAccount(double totalAmount, double amountPaid) implementa conta {}

Conta conta= new CreditCardAccount(10000, 1000);

alternar (forma) {
caso SavingAccount s:
System.out.println("Saldo da conta é " saldo);
quebrar;
caso CartãodeCréditoConta c:
System.out.println("Saldo de crédito é: " (creditLimit-used));
quebrar;
caso HomeLoanAccount h:
System.out.println("Saldo " (totalValor-valorPago));
quebrar;
padrão:
System.out.println("Conta Desconhecida");
}

5. Padrões aninhados
Além de extrair valores de um único registro, os padrões de registro também podem ser aninhados para lidar com registros mais complexos. Digamos que temos um registro chamado “Conta” que possui um campo do tipo “Cliente” e outro campo do tipo “Endereço”. Podemos usar padrões de registro aninhados para extrair os valores de ambos os campos, conforme mostrado no exemplo a seguir:

registro Cliente(String primeiroNome, String sobrenome, int idade) {}

registro de conta(custo do cliente, endereço) {}

Cliente cliente = novo Cliente("John", "Doe", 25);
Endereço endereço = new Endereço("123 Main St.","Cidade", "Estado");
Conta conta = nova conta(cliente, endereço);

if (instância de conta de Conta(Cliente(fNome, lNome, idade), Endereço(rua, cidade, estado))) {
System.out.println("Nome: "fNome); // John
System.out.println("Sobrenome: "lNome); // Doe
System.out.println("Idade: "idade); //25
System.out.println("Endereço: "rua", "cidade", "estado); // Rua Principal 123, Cidade, Estado
}

Neste exemplo, usamos dois padrões aninhados para extrair os valores dos campos "Cliente" e "Endereço" do registro "Conta".

6. Correspondência de componentes
Os padrões de registro permitem mais flexibilidade, pois as variáveis ​​de padrão não precisam corresponder aos nomes dos componentes de um registro. Contanto que sejam compatíveis, a correspondência de padrões será bem-sucedida. Por exemplo:

registro Cliente(String primeiroNome, String sobrenome, int idade) {}

registro de conta(custo do cliente, endereço) {}

Cliente cliente = novo Cliente("John", "Doe", 25);

if (instância do cliente do Cliente(var fn, var ln, var idade)) {
System.out.println("Nome: "fn); // John
System.out.println("Sobrenome: "ln); // Doe
System.out.println("Idade: "idade); //25
}

// Acessando componentes de registro aninhados
Conta conta = nova conta(cliente, novo endereço("123 Main St", "Nova York", "NY"));
if (instância de conta da conta (var cust, var endereço)) {
System.out.println("Cliente: "custo); // Cliente[firstName=John, lastName=Doe, age=25]
System.out.println("Endereço:" endereço); // Endereço[rua=123 Main St, cidade=Nova York, estado=NY]
}

Aqui, as variáveis ​​padrão "fn" e "ln" são diferentes dos nomes dos componentes correspondentes de "fName" e "lName" no registro "Cliente". Isso torna os padrões de registro mais flexíveis e evita possíveis conflitos com nomes de variáveis.

7. Conclusão
Concluindo, os padrões de registro Java fornecem uma maneira conveniente de desconstruir registros e extrair valores deles. Eles tornam o código mais conciso, limpo e legível enquanto lidam com a correspondência de padrões em instruções instanceof e switch. Os padrões de registro, combinados com destruidores de registros, permitem um tratamento mais robusto de registros complexos. No geral, esse recurso aprimora o uso de registros como suportes de dados e torna a programação Java mais agradável.

Os desenvolvedores podem descobrir mais recursos do Java 21 estudando para o exame SE 21 Developer Certified Professional com o uso dos testes práticos 1Z0-830 do MyExamCloud.