Vad är oföränderliga objekt och varför ska man använda dem?

Question

Accepted Answer

Ett **oföränderligt objekt** kan inte ändras efter att det har konstruerats — varje fält ställs in en gång och det finns inga metoder som muterar tillstånd. För att "ändra" det skapar du ett nytt objekt.

## Bygga en oföränderlig typ

```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` modifierar inte `this`; det returnerar en ny `Money`.

## Varför oföränderlighet 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
```

## Avvägningar

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

Vara försiktig med *grund* oföränderlighet: ett `final` fält som pekar på en föränderlig lista är fortfarande föränderlig genom den referensen. Kopiera defensivt eller använd omodifierbara samlingar.

## Varför det är viktigt

Oföränderlighet eliminerar en helt egen klass av buggar: ingenting kan ändra ett objekt bakom din rygg, så resonemang och samtidighet blir dramatiskt enklare.

Det är varför värdetyper (strängar, `LocalDate`, poster) är oföränderliga i moderna språk — delade, cachade och använda som nycklar på ett säkert sätt utan defensiv kopiering.