Immutability – Warum Unveränderlichkeit so wichtig ist

Java • 22. Dezember 2025 • Lesezeit: 6 Minuten

Wenn du in Java programmierst, wirst du früher oder später auf den Begriff Immutability stoßen. Wörtlich übersetzt bedeutet das „Unveränderlichkeit“. Eine immutable Klasse ist also eine Klasse, deren Objekte nach ihrer Erstellung nicht mehr verändert werden können.

Warum ist das so wichtig? Ganz einfach: Wenn ein Objekt nach seiner Erzeugung unveränderlich bleibt, ist es automatisch thread-sicher, leichter zu verstehen, zu testen und zu verwenden. Außerdem kannst du dich darauf verlassen, dass sich einmal gesetzte Werte nicht plötzlich ändern - weder versehentlich noch absichtlich.

Ein einfaches Beispiel: Mutable vs. Immutable

Schauen wir uns zuerst ein einfaches Beispiel an, wie es nicht immutable ist:

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

public class Main {
    public static void main(String[] args) {
        Person p = new Person("Anna", 25);
        System.out.println(p.getName()); // Anna
        p.setName("Tom");
        System.out.println(p.getName()); // Tom
    }
}

Hier sehen wir: Das Objekt p kann nach seiner Erstellung beliebig verändert werden. Wenn man irgendwo im Code den Namen ändert, kann das an anderer Stelle unerwartete Auswirkungen haben. Genau das wollen wir mit Immutability vermeiden.

Wie sieht eine immutable Klasse aus?

Damit eine Klasse unveränderlich ist, müssen einige einfache Regeln beachtet werden:

1. Alle Felder sind private und final.
2. Es gibt keine Setter.
3. Der Zustand des Objekts wird nur im Konstruktor festgelegt.
4. Wenn du komplexe Objekte als Felder verwendest, sollten diese selbst immutable sein - oder du machst Kopien davon.

Hier die immutable Variante unserer Person-Klasse:

public final class ImmutablePerson {
    private final String name;
    private final int age;

    public ImmutablePerson(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

public class Main {
    public static void main(String[] args) {
        ImmutablePerson p = new ImmutablePerson("Anna", 25);
        System.out.println(p.getName()); // Anna
        // p.setName("Tom"); // Gibt es nicht mehr!
    }
}

Jetzt ist das Objekt ImmutablePerson nach seiner Erstellung festgelegt. Niemand kann die Werte ändern. Wenn du eine Person mit anderem Namen brauchst, musst du ein neues Objekt erzeugen:

ImmutablePerson p1 = new ImmutablePerson("Anna", 25);
ImmutablePerson p2 = new ImmutablePerson("Tom", 25);

System.out.println(p1.getName()); // Anna
System.out.println(p2.getName()); // Tom

Das mag auf den ersten Blick umständlicher erscheinen, aber es sorgt für deutlich mehr Sicherheit im Code. Keine Methode kann heimlich etwas verändern.

Immutable bedeutet nicht nutzlos

Viele Java-Klassen, die du täglich nutzt, sind immutable. Zum Beispiel ist String unveränderlich:

public class Main {
    public static void main(String[] args) {
        String s = "Hallo";
        s.concat(" Welt");
        System.out.println(s); // Hallo
        s = s.concat(" Welt");
        System.out.println(s); // Hallo Welt
    }
}

Hier siehst du: s.concat(" Welt") verändert den ursprünglichen String nicht, sondern gibt einen neuen zurück. Erst wenn du das Ergebnis einer neuen Variable zuweist, entsteht eine veränderte Variante. Das ist das Grundprinzip der Immutability.

Warum ist das so hilfreich?

Ein unveränderliches Objekt ist wie ein Stück Papier, auf dem du einmal etwas schreibst - danach bleibt es so. Wenn du eine Änderung brauchst, machst du einfach eine neue Kopie mit dem neuen Inhalt. Das hilft vor allem, wenn mehrere Threads gleichzeitig mit demselben Objekt arbeiten. Da sich der Zustand nicht ändert, müssen keine Synchronisierungen oder Sperren verwendet werden.

Beispiel: Angenommen, mehrere Threads teilen sich dieselbe ImmutablePerson-Instanz. Da diese sich nicht verändert, kann keiner der Threads versehentlich etwas kaputt machen. Bei einer veränderlichen Klasse wie Person wäre das dagegen gefährlich.

Was tun bei Listen oder anderen Objekten?

Manchmal enthält eine Klasse Sammlungen oder komplexe Objekte. Wenn du sie einfach so speicherst, könnte der Aufrufer sie nachträglich verändern. Beispiel:

public final class MutableListExample {
    private final List items;

    public MutableListExample(List items) {
        this.items = items; // Problem: Liste kann von außen veraendert werden
    }

    public List getItems() {
        return items;
    }
}

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Anna");
        MutableListExample ex = new MutableListExample(names);
        names.add("Tom");
        System.out.println(ex.getItems()); // [Anna, Tom] - oops!
    }
}

Hier hat sich der Inhalt der Liste im Objekt geändert, obwohl es immutable wirken sollte. Die Lösung: Wir machen eine defensive Kopie der Liste:

public final class ImmutableListExample {
    private final List items;

    public ImmutableListExample(List items) {
        this.items = new ArrayList<>(items); // defensive Kopie
    }

    public List getItems() {
        return new ArrayList<>(items); // neue Kopie zurueckgeben
    }
}

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Anna");
        ImmutableListExample ex = new ImmutableListExample(names);
        names.add("Tom");
        System.out.println(ex.getItems()); // [Anna]
    }
}

Jetzt bleibt die interne Liste des Objekts immer gleich. Niemand außerhalb der Klasse kann sie verändern.

Fazit

Immutability klingt anfangs nach zusätzlichem Aufwand, aber sie sorgt für Stabilität, Einfachheit und Sicherheit im Code. Besonders in größeren Anwendungen oder bei nebenläufiger Programmierung ist sie Gold wert.

Wenn du beginnst, eigene Klassen zu schreiben, überlege dir: Soll dieses Objekt nach der Erstellung wirklich verändert werden können? Wenn nicht - mach es immutable. Du wirst schnell merken, dass du dadurch weniger Fehler hast und dein Code deutlich klarer wird.

Oder um es kurz zu sagen: Immutable Objekte sind wie gute Verträge - einmal unterschrieben, bleiben sie so, wie sie sind.