O que são objetos imutáveis e por que usá-los?

Question

Accepted Answer

Um **objeto imutável** não pode ser alterado após sua construção — cada campo é definido uma vez e não há métodos que mutem o estado. Para "alterá-lo", você cria um novo objeto.

## Construindo um tipo imutável

```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` não modifica `this`; retorna um novo `Money`.

## Por que a imutabilidade ajuda

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

## Desvantagens

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

Cuidado com a imutabilidade *superficial*: um campo `final` apontando para uma lista mutável ainda é mutável através dessa referência. Copie defensivamente ou use coleções imutáveis.

## Por que isso importa

A imutabilidade elimina uma classe inteira de bugs: nada pode mudar um objeto por baixo de você, então o raciocínio e a concorrência ficam drasticamente mais simples.

É por isso que tipos de valor (strings, `LocalDate`, records) são imutáveis em linguagens modernas — compartilhados, em cache e usados como chaves com segurança sem cópias defensivas.