Waarom is onveranderlijkheid zo belangrijk in…

Onveranderlijkheid biedt een reeks voordelen:

Veiligheid in multithread-omgevingen: Onveranderlijke objecten kunnen veilig worden gedeeld tussen threads zonder synchronisatie of vergrendelingen, wat de ontwikkeling van multithread-toepassingen vereenvoudigt en racecondities voorkomt.
Voorspelbaarheid: De toestand van een onveranderlijk object verandert nooit na creatie. Dit vergemakkelijkt het begrijpen van de gegevensstroom in het programma en het debuggen, omdat je precies weet dat het object niet onverwacht zal veranderen.
Caching en memoisatie: Onveranderlijke objecten zijn gemakkelijk te cachen. Als twee objecten gelijk zijn (equals), zullen hun hash-codes altijd gelijk zijn (uitgaande van een correcte implementatie van hashCode), en hun toestand verandert niet, waardoor veilig hergebruik van berekende resultaten mogelijk is.
Vereenvoudiging van ontwerp: Ontwerpen met onveranderlijke objecten kan leiden tot meer modulaire en begrijpelijke code. Functies die onveranderlijke objecten accepteren en teruggeven, zijn puur en hebben geen bijwerkingen op de invoergegevens.
Verbetering van prestaties in sommige gevallen: Hoewel het creëren van een nieuw object bij elke wijziging ondoeltreffend kan lijken, is de garbage collector van de JVM geoptimaliseerd voor het werken met veel kortelevende objecten, en het ontbreken van vergrendelingen in multithread-omgevingen kan de kosten compenseren.

Voorbeeld van het maken van een onveranderlijke klasse:

public final class ImmutableClass {

    private final int value;
    private final String name;

    public ImmutableClass(int value, String name) {
        this.value = value;
        this.name = name;
    }

    public int getValue() {
        return value;
    }

    public String getName() {
        return name;
    }

    // Geen setters
    // Final velden
    // Final klasse
    // Alle velden primitief of onveranderlijke objecten,
    // of geven kopieën van veranderlijke objecten terug indien nodig (hier niet)

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        ImmutableClass that = (ImmutableClass) o;
        if (value != that.value) return false;
        return name != null ? name.equals(that.name) : that.name == null;
    }

    @Override
    public int hashCode() {
        int result = value;
        result = 31 * result + (name != null ? name.hashCode() : 0);
        return result;
    }
}

Waarom is onveranderlijkheid zo belangrijk in programmeren?