不可變類一旦創(chuàng)建后其狀態(tài)不能被修改，任何操作都會(huì)返回新對(duì)象。要在Java中實(shí)現(xiàn)不可變類，需遵循以下步驟：1. 將類聲明為final；2. 所有字段設(shè)為private和final；3. 僅提供getter方法，不提供setter；4. 所有字段必須在構(gòu)造函數(shù)中初始化；5. 對(duì)于可變類型的字段，在賦值和獲取時(shí)進(jìn)行防御性拷貝。此外，Java 9起支持內(nèi)置不可變集合如List.of()等，有助于減少樣板代碼并防止意外修改。只要注意類的設(shè)計(jì)和內(nèi)部狀態(tài)保護(hù)，就能在Java中實(shí)現(xiàn)真正的不可變性。

Immutability means that once an object is created, its state cannot be changed. Any operation that would normally modify the object instead returns a new object with the updated state. This concept is important in programming because it helps avoid side effects, makes code easier to reason about, and improves thread safety.

Java isn’t built around immutability by default — most objects are mutable unless designed otherwise. But you can definitely create immutable classes if you follow certain rules.

What Makes a Class Immutable in Java?

An immutable class must ensure that its internal state remains constant after creation. Here's what you need to do:

• Make the class final — prevents subclasses from changing behavior.
• Make all fields private and final — ensures they can't be modified externally or internally after construction.
• Don't provide setter methods — only getters, if needed.
• Initialize all fields via constructor only — no other way to change values later.
• If a field is mutable (like collections or other objects), return defensive copies — so changes don’t affect the internal state.

For example, if your class contains a List<string></string>, returning the list directly could allow outside code to modify it. Instead, return a new copy of the list inside a getter.

Common Mistakes That Break Immutability

Even when trying to build immutable classes, some common mistakes can break immutability:

• Returning references to mutable internal objects, like collections or arrays.
• Allowing subclassing, which might override methods and introduce mutability.
• Initializing fields outside the constructor, for example through setters or public fields.

Let’s say you have a class with a Date field. If you expose that date object directly, someone could call setTime() on it and change your supposedly immutable object's internal state.

So always:

• Return defensive copies of mutable objects.
• Make sure all fields are initialized in the constructor.
• Avoid any method that changes the object’s state.

How to Achieve Immutability Step by Step

Here’s how to actually implement an immutable class in Java:

1. Declare the class as final.
2. Make all fields private and final.
3. Only define getters — no setters.
4. Initialize all fields through the constructor.
5. If using mutable types (like List, Date, etc.), make defensive copies during both assignment and retrieval.

public final class Person {
    private final String name;
    private final List<String> hobbies;

    public Person(String name, List<String> hobbies) {
        this.name = name;
        this.hobbies = new ArrayList<>(hobbies); // Defensive copy
    }

    public String getName() {
        return name;
    }

    public List<String> getHobbies() {
        return new ArrayList<>(hobbies); // Return a copy
    }
}

This way, even if someone modifies the list returned by getHobbies(), the original object stays unchanged.

Use Built-in Immutable Collections When Possible

Since Java 9, there are built-in immutable collections like List.of(), Set.of(), and Map.of(). These are handy when you want to return unmodifiable collections without manually wrapping or copying them.

Using these helps reduce boilerplate and avoids accidental modification attempts. Trying to add or remove elements from such collections will throw an UnsupportedOperationException.

基本上就這些。只要注意類的設(shè)計(jì)和內(nèi)部狀態(tài)的保護(hù)，就能在 Java 中實(shí)現(xiàn)真正的不可變性。

以上是什么是不變性以及如何在Java中實(shí)現(xiàn)它？的詳細(xì)內(nèi)容。更多信息請(qǐng)關(guān)注PHP中文網(wǎng)其他相關(guān)文章！