Cosa sono gli oggetti immutabili e perché usarli?

Question

Accepted Answer

Un **oggetto immutabile** non può essere modificato dopo la costruzione — ogni campo viene impostato una volta sola, e non ci sono metodi che mutano lo stato. Per "modificarlo", si crea un nuovo oggetto.

## Costruire un tipo immutabile

```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` non modifica `this`; restituisce un nuovo `Money`.

## Perché l'immutabilità aiuta

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

## Trade-off

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

Fai attenzione all'immutabilità *superficiale*: un campo `final` che punta a una lista mutabile è ancora mutabile attraverso quel riferimento. Copia difensivamente o usa collezioni non modificabili.

## Perché è importante

L'immutabilità elimina un'intera classe di bug: nulla può cambiare un oggetto alle tue spalle, quindi il ragionamento e la concorrenza diventano drasticamente più semplici.

È per questo che i tipi di valore (stringhe, `LocalDate`, record) sono immutabili nei linguaggi moderni — condivisi, cachati, e utilizzati come chiavi in modo sicuro senza copia difensiva.