A imutabilidade é muito desejável na programação. Ele permite um comportamento previsível, consistente e seguro dos objetos, tornando mais fácil raciocinar sobre o código, melhorando o desempenho e garantindo que o código seja mais robusto e menos propenso a erros. Com base na minha experiência, aqui estão 5 maneiras de incorporar a imutabilidade em sua base de código —

1. Campos finais

Uma das maneiras mais simples de obter imutabilidade em Java é usar campos finais . Um campo final só pode receber um valor uma vez, no construtor ou durante a inicialização do objeto. Aqui está um exemplo:

public final class Person {
  private final String firstName;
  private final String lastName;
  public Person(String firstName, String lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
  }
  public String getFirstName() {
    return firstName;
  }
  public String getLastName() {
    return lastName;
  }
}

Uma das bibliotecas mais populares para criar objetos imutáveis ​​em Java é a biblioteca Immutables do Google Guava . Ele permite que você crie objetos imutáveis ​​de maneira simples e consistente, além de oferecer suporte a recursos mais avançados, como validação personalizada e coleções. Aqui está um exemplo:

@Value.Immutable
public interface Person {
  String firstName();
  String lastName();
}

Use @NonNull, @Nullable ou outras anotações de nível de tipo. Para evitar valores nulos nos campos de objetos imutáveis ​​e torná-los explícitos, é uma boa prática usar anotações em nível de tipo como @NonNull, @Nullable ou outras para especificar a nulidade dos campos. Isso pode ajudar a detectar erros no início e tornar o código mais legível. Aqui está um exemplo:

public final class Person {
  private final @NonNull String firstName;
  private final @NonNull String lastName;
  public Person(@NonNull String firstName, @NonNull String lastName) {
    this.firstName = firstName;
    this.lastName
  }
}

Usar uma classe de construtor para criar objetos imutáveis ​​é uma técnica poderosa que permite criar objetos imutáveis ​​complexos com uma interface simples e consistente. A classe builder pode ser usada para definir valores para as propriedades do objeto e, em seguida, um método build é chamado para criar o objeto imutável com as propriedades definidas. Isso permite criar objetos imutáveis ​​com muitos campos opcionais e garante que os objetos sejam criados de maneira consistente.

@Value.Immutable
public interface Person {
    String firstName();
    String lastName();
    int age();
    String address();
    @Value.Builder
    interface Builder {
        Builder firstName(String firstName);
        Builder lastName(String lastName);
        Builder age(int age);
        Builder address(String address);
        Person build();
    }
}

Uma das melhores maneiras de garantir a imutabilidade é usar objetos de valor. Objetos de valor são objetos pequenos e imutáveis ​​que representam um único valor, como um endereço de e-mail ou uma data. Eles são normalmente usados ​​para encapsular a lógica de validação e podem ser usados ​​em vez de primitivos para deixar claro que tipo de dados uma variável representa. Aqui está um exemplo:

public final class Email {
    private final String email;

    public Email(String email) {
        if (!email.matches("^[a-zA-Z0-9_!#$%&’*+/=?`{|}~^.-]+@[a-zA-Z0-9.-]+$")) {
            throw new IllegalArgumentException("Invalid email address");
        }
        this.email = email;
    }

    public String getEmail() {
        return email;
    }
}

Para levar suas habilidades de desenvolvimento Java para o próximo nível, certifique-se de verificar e seguir Java Eficaz !