Wat zijn immutable objects en waarom zou je ze gebruiken?

Question

Accepted Answer

Een **immutable object** kan niet worden gewijzigd nadat het is aangemaakt — elk veld wordt eenmaal ingesteld en er zijn geen methoden die de toestand wijzigen. Om het te "wijzigen" maakt u een nieuw object.

## Een immutable type bouwen

```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` wijzigt `this` niet; het retourneert een nieuw `Money`.

## Waarom immutabiliteit helpt

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

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

Pas op voor *ondiepe* immutabiliteit: een `final` veld dat naar een mutable list wijst, is nog steeds mutable via die referentie. Kopieer verdedigend of gebruik onveranderbare collections.

## Waarom het belangrijk is

Immutabiliteit elimineert een hele klasse van bugs: niets kan een object onder je vandaan veranderen, dus redeneren en gelijktijdigheid worden dramatisch eenvoudiger.

Het is waarom value types (strings, `LocalDate`, records) immutable zijn in moderne talen — gedeeld, gecachet en veilig gebruikt als sleutels zonder verdedigende kopieën.