Records no Java, conheça esse novo recurso

Records no Java, conheça esse novo recurso – O Java é uma linguagem bastante conhecida pela sua verbosidade, e isso é um fato. Mas, com o passar dos anos, a linguagem vem ganhando novos recursos que tornam o código mais conciso e legível. Além disso, também existem bibliotecas que ajudam a diminuir a quantidade de código que precisamos escrever. Uma dessas bibliotecas é o Lombok. Neste artigo, vamos conhecer um recurso do Java que é bastante útil e foi introduzido no Java 14: os Records.

O que são Records?

(Conheça o recurso de Records no Java)

Sobretudo Records são uma nova forma de declarar classes no Java. Eles são imutáveis por padrão, o que significa que não podemos alterar seus valores após a criação do objeto. Além disso, eles são bastante úteis para representar dados, como, por exemplo, uma entidade de banco de dados.

Esse recurso foi introduzido primeiramente no Java 14 como experimental, e a partir do Java 16 foi marcado como estável. Assim significando que podemos utilizá-lo em nossos projetos sem medo de que ele seja removido em uma versão futura do Java.

Quais as vantagens e desvantagens de utilizar Records?

O recurso de Records no Java nos dá algumas vantagens, como, por exemplo:

• Sintaxe mais concisa: Records permitem definir classes de dados imutáveis de forma mais concisa, contudo que elimine a necessidade de escrever o código repetitivo que normalmente é necessário para definir uma classe Java.
• Redução de código boilerplate: Como os Records fornecem métodos padrão, como equals(), hashCode() e toString(), eles reduzem a quantidade de código boilerplate necessário para definir uma classe Java.
• Imutabilidade: Como os Records são imutáveis por padrão, eles fornecem uma maneira mais segura e fácil de trabalhar com dados imutáveis.
• Mais fácil de ler e manter: A sintaxe simplificada do Records torna mais fácil de ler e manter o código, pois é mais fácil de entender a intenção do código.
• Melhor compatibilidade com APIs existentes: Os Records tiveram projetos para serem compatíveis com as APIs existentes. Permitindo que os desenvolvedores usem Records em conjunto com outras classes Java sem problemas.

Por outro lado, eles também possuem algumas desvantagens, como, por exemplo:

• Restrições na personalização de métodos: Por padrão, os Records fornecem métodos padrão, como equals(), hashCode() e toString(), que não podem ser personalizados.
• Limitações na herança: Os Records não suportam herança de classe, assim significa que não é possível estender um Record em outra classe. Isso pode ser um problema se você precisar adicionar funcionalidade a uma classe Record existente.
• Maior complexidade em casos complexos: Em casos complexos, os Records primeiramente podem se tornar mais difíceis de entender e manter do que as classes Java normais. Devido a uma sintaxe mais compacta e a recursos específicos que podem ser difíceis de entender.
• Restrições de visibilidade: a visibilidade dos campos e formas em um record tem limites. Todos os campos são automaticamente finais e privados, e os métodos são todos públicos.

Como declarar um Record?

(Conheça o recurso de Records no Java)

Para declarar um Record, precisamos utilizar a palavra-chave record seguida do nome da classe. Em seguida, devemos declarar os campos que o Record terá, declarados como se fossem variáveis locais. Por fim, devemos declarar o construtor da classe, declarado como se fosse um método. Veja o exemplo abaixo:

public record Person(String name, int age) {}

Pelo exemplo acima, criamos um Record chamado Person que possui dois campos: name e age. O Record acima é equivalente à classe abaixo:

public class Person {

    private final String name;

    private final int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        result = prime * result + age;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Person other = (Person) obj;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        if (age != other.age)
            return false;
        return true;
    }

    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
}

O recurso de Records no Java diminui bastante a quantidade de código que precisamos escrever para criar uma classe.

Como acessar os campos de um Record?

Para acessar os campos de um Record, primeiramente podemos utilizar os métodos get() que são gerados automaticamente. Veja o exemplo abaixo:

public class Main {

    public static void main(String[] args) {
        Person person = new Person("John", 30);
        System.out.println(person.name());
        System.out.println(person.age());
    }

}

Podemos assim ver uma particularidade dos Records, os métodos assessores são gerados com o mesmo nome dos campos, ou seja. Não precisamos utilizar o prefixo get para acessar os campos. Além disso, os métodos assessores são gerados como public, o que significa que podemos acessá-los de qualquer lugar.

Customizando construtores

(Conheça o recurso de Records no Java)

Por padrão, os Records geram sobretudo um construtor público com todos os campos como parâmetros. No entanto, podemos personalizar o construtor de um Record. Veja o exemplo abaixo:

public record Person(String name, int age) {

    public Person {
        if (name == null) {
            throw new IllegalArgumentException("Name cannot be null");
        }
        if (age < 0) {
            throw new IllegalArgumentException("Age cannot be negative");
        }
    }

}

Com o exemplo acima, criamos um construtor personalizado para o Record Person. Nesse construtor, verificamos se o nome é nulo e se a idade é negativa. Caso seja, lançamos uma exceção.

Também podemos criar assim mais de um construtor para um Record, por exemplo, podemos criar um construtor que recebe apenas o nome e define a idade como 0. Veja o exemplo abaixo:

public record Person(String name, int age) {

    public Person(String name, int age) {
        this(name, age);
    }

    public Person(String name) {
        this(name, 0);
    }

}

No exemplo acima, criamos dois construtores personalizados para o Record Person. O primeiro construtor recebe o nome e a idade como parâmetros e o segundo construtor recebe apenas o nome como parâmetro. No segundo construtor, definimos a idade como 0.

É importante observar que a sintaxe que utilizamos no primeiro exemplo para criar um construtor personalizado difere da sintaxe que utilizamos no segundo exemplo. A do primeiro exemplo chama-se construtor compacto.

Utilizando Records

(Conheça o recurso de Records no Java)

Sobretudo são uma ótima opção para representar dados, como, por exemplo, DTOs (Data Transfer Objects). Além disso, eles são uma ótima opção para representar dados que não precisam de alteração após a criação do objeto, como, por exemplo, configurações de aplicação.

Um ponto importante a se considerar é que os Records não são uma boa opção para representar entidades de banco de dados. Pois eles não suportam herança, o que significa que não é possível estender um Record em outra classe. Além disso, pelo fato de os Records serem imutáveis por padrão, eles não podem ser utilizados para representar entidades da JPA , pois esta necessita de entidades mutáveis.

Conclusão

Primeiramente neste artigo, vimos como utilizar o recurso de Records no Java. O recurso de Records no Java nos permite criar classes de dados imutáveis de forma mais concisa. Assim eliminando a necessidade de escrever o código repetitivo que normalmente é necessário para definir uma classe Java.

Além disso, eles também nos dão algumas vantagens. Como, por exemplo: Uma sintaxe mais concisa, redução de código boilerplate, imutabilidade, mais fácil de ler e manter, e melhor compatibilidade com APIs existentes. Por outro lado, eles também possuem algumas desvantagens. Como, por exemplo: Restrições na personalização de métodos, limitações na herança, maior complexidade em casos complexos, e restrições de visibilidade.

Caso queira aprender mais sobre o Java, saiba que aqui na Café Codificado com nosso curso.

Leia também o artigo “Top 10 livros para Desenvolvedores“