A introdução dos registros Java forneceu aos desenvolvedores uma nova estrutura de dados que simplifica o manuseio e a criação de objetos de dados. Com a mais recente adição de padrões de registro e padrões aninhados, o manuseio de registros tornou-se ainda mais eficiente e dinâmico.

Vamos começar revisando o básico - um registro é uma alternativa leve às classes tradicionais que serve como um transportador transparente para dados com métodos de acesso integrados. Seu principal objetivo é reter dados em vez de implementar comportamentos complexos.

No entanto, com a introdução de padrões de registro no Java 21, o idioma tradicional instanceof-and-cast foi simplificado. Em vez de verificar se um objeto é uma instância de uma classe de registro específica e depois convertê-lo para usar seus componentes, agora podemos usar um padrão de registro para combinar as duas etapas. Por exemplo, em vez de escrever isto:

if (obj instanceof String) {
    String name = (String)obj;
    ... use name ...
}
In Java 21, we can simply write:

if (obj instanceof String name) {
    ... use name ...
}

Isso torna o código mais conciso e menos sujeito a erros, já que o tipo padrão String s é usado para corresponder ao valor de obj e inicializar a variável padrão s com o valor de obj que foi convertido em String.

Além disso, Java 21 também introduz padrões aninhados, que permitem a correspondência e decomposição de gráficos de objetos mais complexos, como registros aninhados. Digamos que temos as seguintes declarações:

Record BankAccount(String accountNumber, String accountHolder, double balance) {}
Record Transaction(String transactionId, double amount, String type, String timestamp) {}
Record BankStatement(List transactions, BankAccount account) {}

Agora podemos usar um padrão de registro aninhado para calcular o valor total da transação de um objeto BankStatement da seguinte forma:

static double calculateTotalTransactions(BankStatement statement) {
    if (statement instanceof BankStatement(List transactions, BankAccount account)) {
        double total = 0;
        for (Transaction t : transactions) {
            total  = t.amount;
        }
        return total;
    }
    return 0;
}

Neste exemplo, o padrão externo BankStatement(List transaction, BankAccount account) contém um padrão aninhado BankAccount account que é usado para extrair o componente de conta do registro BankStatement. Isso permite um código mais conciso e eficiente, já que não precisamos lidar com cada correspondência de subpadrão individual separadamente.

Outro recurso útil dos padrões de registro é a inferência de tipo. Quando um padrão de registro nomeia uma classe de registro genérica sem fornecer nenhum argumento de tipo, o compilador inferirá automaticamente os argumentos de tipo quando o padrão for usado. Isso simplifica o código, conforme mostrado no exemplo a seguir:

record MyBankAccount(L limitFactor, M money){};

static void recordInference(MyBankAccount bankaccount){
    switch(bankaccount){
        case MyBankAccount(var moneylimit, var amount) ->
            System.out.println("Messages: Inferred that account has balance "   amount   " with a limit of "   moneylimit);
        case MyBankAccount(var moneylimit, null)->
            System.out.println("Messages: Inferred that account has a balance of zero with a limit of "   moneylimit);
        ...
    }
}

Esse recurso também é compatível com padrões de registro aninhados, tornando o código ainda mais conciso e legível.

Finalmente, os padrões de registro são totalmente integrados às expressões e instruções switch em Java 21. No entanto, é importante observar que ao usar padrões de registro em instruções switch, o bloco switch deve ser exaustivo. Isso significa que todos os valores possíveis da expressão do seletor devem ser considerados no bloco switch. Com padrões de registro, isso é determinado pela análise dos tipos de padrões usados. Por exemplo, o rótulo de caso case Bar b corresponderá aos valores do tipo Bar e a todos os subtipos possíveis de Bar.

Concluindo, compreender e dominar os padrões de registro em Java 21 é crucial para qualquer pessoa que se prepara para a Certificação de Desenvolvedor Java SE 21. Esses novos recursos permitem um manuseio de registros mais simplificado e eficiente, tornando-se uma habilidade essencial para desenvolvedores Java.