final在Java中不等於對像不可變，它只保證變量引用不可重新賦值，而不保證所指向?qū)ο蟮臓顟B(tài)不可變；2. 對於基本類型，final確保值不變；對於對像類型，引用不可變但對象內(nèi)容仍可修改；3. 實(shí)現(xiàn)真正不可變需滿足：類聲明為final、所有字段為private final、無setter方法、構(gòu)造函數(shù)初始化且不洩漏可變狀態(tài)；4. 若字段為可變對象，需通過防禦性拷貝和返回不可修改視圖來防止外部修改；5. final字段具有JMM內(nèi)存模型保障，確保多線程下正確發(fā)布對象；6. 常見誤區(qū)是認(rèn)為final自動(dòng)帶來不可變性，實(shí)際上final僅鎖定引用，對象自身仍可能可變。

The final keyword in Java is often associated with immutability, but it's important to understand what it actually guarantees—and what it doesn't. Many developers assume that marking something as final makes it immutable, but that's only part of the story. Let's break this down clearly.

What final Actually Means

The final keyword can be applied to variables, methods, and classes, and it has a different meaning in each context:

• final variable : The variable cannot be reassigned once initialized.
• final method : The method cannot be overridden in a subclass.
• final class : The class cannot be subclassed.

When people talk about immutability, they're usually focusing on final variables—especially object references.

 final int x = 5;
x = 10; // Compile error!

final List<String> list = new ArrayList<>();
list.add("Hello"); // This is allowed
list = new ArrayList<>(); // Compile error!

Notice: the list reference is final, so you can't point it to a new object, but the object it refers to can still be modified.

final ≠ Immutability

Here's the key point: final ensures reference immutability, not object immutability.

That means:

• You can't change where the final variable points.
• But if it points to a mutable object (like an ArrayList ), the contents of that object can still change.

So this code compiles and runs just fine:

 final StringBuilder sb = new StringBuilder("Hello");
sb.append(" World"); // Perfectly legal

The reference sb is fixed, but the object it refers to is mutable, so its internal state changes.

To achieve true immutability, you need:

1. A final reference (so it can't be reassigned), and
2. An object whose internal state cannot change.

How to Achieve True Immutability

For a class to be truly immutable, follow these practices:

• Declare the class as final (or ensure all methods are final and construction is controlled).
• Make all fields private and final .
• Don't provide setter methods.
• Initialize all fields via constructor, and don't expose mutable state.
• If fields are objects, make defensive copies when necessary.

Example of an immutable class:

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

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

    public String getName() { return name; }
    public int getAge() { return age; }
}

Now, any instance of Person cannot be changed after creation—this is true immutability.

But watch out for this trap:

 public final class BadImmutable {
    private final List<String> hobbies;

    public BadImmutable(List<String> hobbies) {
        this.hobbies = hobbies; // No defensive copy!
    }

    public List<String> getHobbies() {
        return hobbies;
    }
}

Even though hobbies is final , the list passed in can still be modified externally unless you make a defensive copy:

 this.hobbies = new ArrayList<>(hobbies); // Safe copy

And return it as unmodifiable:

 public List<String> getHobbies() {
    return Collections.unmodifiableList(hobbies);
}

Common Misconceptions

• ? " final makes an object immutable" → No, it only makes the reference constant.
• ? "Immutable objects don't need final fields" → Without final , even if you don't provide setters, the field could theoretically be changed via reflection or in multi-threaded contexts.
• ? final helps the JVM optimize and enforces safe publication in threads (especially for immutable objects).

In fact, the Java Memory Model gives special guarantees for final fields: once an object is constructed, other threads will see the correct values of final fields without additional synchronization.

Summary

• final on a variable means the reference can't be changed.
• It does not prevent modification of the object being referred to.
• True immutability requires both final references and immutable state.
• Use final classes, private final fields, no setters, and defensive copying when needed.

So while final is a critical tool for building immutable objects, it's just one piece of the puzzle. Don't assume final = immutable—look deeper at the object's behavior.

Basically: final locks the reference, not the object.

以上是了解Java'最終”關(guān)鍵字和不變性的詳細(xì)內(nèi)容。更多資訊請關(guān)注PHP中文網(wǎng)其他相關(guān)文章！