L'immuabilité est très souhaitable dans la programmation. Il permet un comportement prévisible, cohérent et sûr des objets, ce qui facilite le raisonnement sur le code, améliore les performances et garantit que le code est plus robuste et moins sujet aux erreurs. D'après mon expérience, voici 5 façons d'intégrer l'immuabilité dans votre base de code —

1. Champs finaux

L'un des moyens les plus simples d'obtenir l'immuabilité en Java consiste à utiliser des champs finaux . Un champ final ne peut recevoir une valeur qu'une seule fois, soit dans le constructeur, soit lors de l'initialisation de l'objet. Voici un exemple:

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

L'une des bibliothèques les plus populaires pour créer des objets immuables en Java est la bibliothèque Immutables de Google Guava . Il vous permet de créer des objets immuables de manière simple et cohérente, et il prend également en charge des fonctionnalités plus avancées telles que la validation personnalisée et les collections. Voici un exemple:

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

Utilisez @NonNull, @Nullable ou d'autres annotations au niveau du type. Pour empêcher les valeurs nulles dans les champs d'objets immuables et pour le rendre explicite, il est recommandé d'utiliser des annotations au niveau du type comme @NonNull, @Nullable ou autres pour spécifier la nullabilité des champs. Cela peut aider à détecter les erreurs dès le début et à rendre le code plus lisible. Voici un exemple:

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

L'utilisation d'une classe de générateur pour créer des objets immuables est une technique puissante qui vous permet de créer des objets immuables complexes avec une interface simple et cohérente. La classe de générateur peut être utilisée pour définir des valeurs pour les propriétés de l'objet, puis une méthode de génération est appelée pour créer l'objet immuable avec les propriétés définies. Cela vous permet de créer des objets immuables avec de nombreux champs facultatifs et garantit que les objets sont créés de manière cohérente.

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

L'un des meilleurs moyens de garantir l'immuabilité consiste à utiliser des objets de valeur. Les objets de valeur sont de petits objets immuables qui représentent une valeur unique, telle qu'une adresse e-mail ou une date. Ils sont généralement utilisés pour encapsuler la logique de validation et peuvent être utilisés à la place des primitives pour indiquer clairement le type de données qu'une variable représente. Voici un exemple:

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

Pour faire passer vos compétences en développement Java au niveau supérieur, assurez-vous de passer à la caisse et de suivre Effective Java !