Hvad er uforanderlige objekter og hvorfor bruger vi dem?

Question

Accepted Answer

Et **uforanderligt objekt** kan ikke ændres efter det er konstrueret — alle felter sættes en gang, og der er ingen metoder, der muterer staten. For at "ændre" det, opretter du et nyt objekt.

## Bygning af en uforanderlig type

```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` ændrer ikke `this`; det returnerer en frisk `Money`.

## Hvordan uforanderlighed hjælper

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

## Afvejninger

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

Vær opmærksom på *overfladisk* uforanderlighed: et `final` felt, der peger på en ændringsparat liste, er stadig ændringsparat gennem denne reference. Kopier defensivt eller brug umodificerbare samlinger.

## Hvorfor det betyder noget

Uforanderlighed eliminerer en hel klasse af fejl: intet kan ændre et objekt bag dit ryg, så ræsonnering og concurrency bliver dramatisk enklere.

Det er grunden til, at værdityper (strings, `LocalDate`, records) er uforanderlige i moderne sprog — delt, cachede og brugt som nøgler sikkert uden defensiv kopiering.