L'immutabilità è molto desiderabile nella programmazione. Consente un comportamento prevedibile, coerente e sicuro degli oggetti, semplificando il ragionamento sul codice, migliorando le prestazioni e garantendo che il codice sia più robusto e meno soggetto a errori. Sulla base della mia esperienza, ecco 5 modi in cui puoi incorporare l'immutabilità nella tua base di codice:

1. Campi finali

Uno dei modi più semplici per ottenere l'immutabilità in Java è utilizzare i campi finali . A un campo final può essere assegnato un valore solo una volta, nel costruttore o durante l'inizializzazione dell'oggetto. Ecco un esempio:

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 delle librerie più popolari per la creazione di oggetti immutabili in Java è la libreria Immutables di Google Guava . Ti consente di creare oggetti immutabili in modo semplice e coerente e supporta anche funzionalità più avanzate come la convalida e le raccolte personalizzate. Ecco un esempio:

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

Usa @NonNull, @Nullable o altre annotazioni a livello di tipo. Per evitare valori nulli nei campi di oggetti immutabili e per renderlo esplicito, è buona norma utilizzare annotazioni a livello di tipo come @NonNull, @Nullable o altre per specificare la nullabilità dei campi. Questo può aiutare a rilevare gli errori nella fase iniziale e rendere il codice più leggibile. Ecco un esempio:

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'utilizzo di una classe builder per creare oggetti immutabili è una tecnica potente che consente di creare oggetti immutabili complessi con un'interfaccia semplice e coerente. La classe builder può essere utilizzata per impostare i valori per le proprietà dell'oggetto, quindi viene chiamato un metodo build per creare l'oggetto immutabile con le proprietà impostate. Ciò consente di creare oggetti immutabili con molti campi facoltativi e garantisce che gli oggetti vengano creati in modo coerente.

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

Uno dei modi migliori per garantire l'immutabilità è utilizzare oggetti di valore. Gli oggetti valore sono piccoli oggetti immutabili che rappresentano un singolo valore, ad esempio un indirizzo e-mail o una data. In genere vengono utilizzati per incapsulare la logica di convalida e possono essere utilizzati al posto delle primitive per chiarire quale tipo di dati rappresenta una variabile. Ecco un esempio:

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

Per portare le tue abilità di sviluppo Java al livello successivo, assicurati di fare il checkout e seguire Effective Java !