La inmutabilidad es muy deseable en la programación. Permite un comportamiento predecible, coherente y seguro de los objetos, lo que facilita el razonamiento sobre el código, mejora el rendimiento y garantiza que el código sea más sólido y menos propenso a errores. Según mi experiencia, aquí hay 5 formas en que puede incorporar la inmutabilidad en su base de código:

1. Campos finales

Una de las formas más simples de lograr la inmutabilidad en Java es usar campos finales . A un campo final solo se le puede asignar un valor una vez, ya sea en el constructor o durante la inicialización del objeto. Aquí hay un ejemplo:

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;
  }
}

Una de las bibliotecas más populares para crear objetos inmutables en Java es la biblioteca Immutables de Google Guava . Le permite crear objetos inmutables de una manera simple y consistente, y también admite funciones más avanzadas como validación personalizada y colecciones. Aquí hay un ejemplo:

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

Use @NonNull, @Nullable u otras anotaciones de nivel de tipo. Para evitar valores nulos en los campos de objetos inmutables y hacerlo explícito, es una buena práctica usar anotaciones de nivel de tipo como @NonNull, @Nullable u otras para especificar la nulabilidad de los campos. Esto puede ayudar a detectar errores desde el principio y hacer que el código sea más legible. Aquí hay un ejemplo:

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 una clase de constructor para crear objetos inmutables es una técnica poderosa que le permite crear objetos inmutables complejos con una interfaz simple y consistente. La clase de constructor se puede usar para establecer valores para las propiedades del objeto y luego se llama a un método de construcción para crear el objeto inmutable con las propiedades establecidas. Esto le permite crear objetos inmutables con muchos campos opcionales y garantiza que los objetos se creen de forma coherente.

@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();
    }
}

Una de las mejores formas de garantizar la inmutabilidad es utilizar objetos de valor. Los objetos de valor son objetos pequeños e inmutables que representan un único valor, como una dirección de correo electrónico o una fecha. Por lo general, se usan para encapsular la lógica de validación y se pueden usar en lugar de primitivas para aclarar qué tipo de datos representa una variable. Aquí hay un ejemplo:

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 llevar sus habilidades de desarrollo de Java al siguiente nivel, asegúrese de pagar y seguir ¡ Java eficaz !