¿Qué son los objetos inmutables y por qué los usamos?

Question

Accepted Answer

Un **objeto inmutable** no puede ser modificado después de ser construido — cada campo se establece una sola vez, y no hay métodos que muten el estado. Para "cambiarlo", creas un nuevo objeto.

## Construyendo un tipo inmutable

```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` no modifica `this`; devuelve un `Money` nuevo.

## Por qué la inmutabilidad ayuda

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

## Compensaciones

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

Cuidado con la inmutabilidad *superficial*: un campo `final` que apunta a una lista mutable sigue siendo mutable a través de esa referencia. Copia defensivamente o usa colecciones inmodificables.

## Por qué es importante

La inmutabilidad elimina toda una clase de errores: nada puede cambiar un objeto a tus espaldas, por lo que el razonamiento y la concurrencia se vuelven dramáticamente más simples.

Es por eso que los tipos de valor (strings, `LocalDate`, records) son inmutables en lenguajes modernos — compartidos, cacheados y usados como claves con seguridad sin copia defensiva.