Que sont les objets immuables et pourquoi les utiliser ?

Question

Accepted Answer

Un **objet immuable** ne peut pas être modifié après sa construction — chaque champ est défini une fois, et il n'existe pas de méthodes qui modifient l'état. Pour le « changer », vous créez un nouvel objet.

## Construire un type immuable

```java
public final class Money {              // final: can't be subclassed to add mutation
    private final int cents;            // final fields, set once
    private final String currency;

public Money(int cents, String currency) {
        this.cents = cents;
        this.currency = currency;
    }

public Money plus(Money other) {    // returns a NEW object, no mutation
        return new Money(this.cents + other.cents, currency);
    }
    public int cents() { return cents; }
}
```

`plus` ne modifie pas `this` ; il retourne un nouvel `Money`.

## Pourquoi l'immuabilité aide

```text
✓ Thread-safe by default → no shared mutable state, no locks needed
✓ Safe to share/cache    → no defensive copies
✓ Valid forever          → if valid at construction, stays valid
✓ Usable as map keys     → hashCode never changes
```

## Compromis

```text
⚠️ Creates new objects on every change → more allocation/GC pressure
⚠️ Awkward for large objects updated frequently (mitigated by builders / persistent
   data structures)
```

Attention à l'immuabilité *superficielle* : un champ `final` pointant vers une liste mutable est toujours mutable via cette référence. Copiez de manière défensive ou utilisez des collections non modifiables.

## Pourquoi c'est important

L'immuabilité élimine toute une classe de bogues : rien ne peut modifier un objet en arrière-plan, donc le raisonnement et la concurrence deviennent dramatiquement plus simples.

C'est pourquoi les types de valeur (chaînes, `LocalDate`, records) sont immuables dans les langages modernes — partagés, mis en cache et utilisés comme clés en toute sécurité sans copie défensive.