作为一名 Java 开发者，你是否曾经在代码调试的深渊中苦苦挣扎，只因某个对象的状态在你毫无察觉的情况下被悄悄改变了？或者，你是否对为什么 String 类的设计如此“特殊”感到好奇？这一切的背后，都隐藏着 Java 面向对象编程中两个至关重要的概念：可变对象与不可变对象。
理解这两个概念不仅仅是为了应付面试，更是为了编写出更安全、更健壮、更易于维护的代码。在这篇文章中，我们将像探险一样深入探讨这两种对象的定义、它们在内存中的表现方式、如何创建它们，以及在实际开发中应该如何权衡使用。
前置知识： 为了更好地理解本文，建议你先对 Java 的面向对象编程（OOP）基本概念（如类、对象、封装）有一定的了解。
注意： 在本文的讨论中，当我们提到对象的“状态”时，指的是该对象在某一特定瞬间所有数据成员（字段）值的快照。
什么是可变对象？
让我们从最直观的概念开始。可变对象是指那些在创建后，其内部状态仍然可以被修改的对象。这意味着，我们可以通过对象提供的方法来改变它所持有的数据。
#### 核心特征
可变对象通常具有以下特征：
- 提供 Setter 方法： 它们通常包含
setter方法，允许外部代码修改其字段的值。 - 就地修改： 当我们修改一个可变对象时，不需要创建新的对象。修改直接作用于当前对象的内存地址上。
- 状态可变： 对象的生命周期内，其状态是不确定的，随时可能因为一次方法调用而改变。
#### 常见的示例
在 Java 标准库中，我们熟悉的 INLINECODE3a147a2b、INLINECODE15abc7fa 以及 java.util.Date 都是典型的可变对象。
#### 为什么我们需要可变对象？
想象一下，如果你正在处理一个巨大的列表，包含数百万条数据。如果你每次对这个列表进行微小的修改（比如添加一个元素），都需要复制整个列表并创建一个新对象，那么内存的消耗和性能的损耗将是巨大的。可变对象允许我们原地修改数据，大大提高了操作效率，尤其是在涉及大量数据修改的场景下。
什么是不可变对象？
与可变对象相反，不可变对象一旦创建，其状态在整个生命周期内就完全固定，无法被修改。
#### 核心特征
不可变对象具有以下严格的约束：
- 无 Setter 方法： 它们不提供任何用于修改内部状态的方法。
- 字段通常为 Final： 所有的字段通常都是
private final的，确保一旦赋值就无法更改。 - 防御性拷贝： 如果它们包含对其他对象的引用（如集合或数组），在构造或返回这些引用时，会进行拷贝以防止外部代码修改内部状态。
- 类通常为 Final： 为了防止子类通过重写方法破坏不可变性，类通常被声明为
final。
#### 常见的示例
最著名的例子莫过于 INLINECODEcad1d69f 类。此外，Java 的基本类型包装类（如 INLINECODE7f53dffa、INLINECODE25e5a244、INLINECODEbe78d697）以及 INLINECODEe3bc8433、INLINECODEc505eaa9 等也都是不可变的。
深入实战：代码示例与解析
光说不练假把式。让我们通过编写具体的代码，来看看如何创建可变和不可变类，以及它们在实际运行中到底有什么区别。
#### 示例 1：创建一个简单的可变类
在这个例子中，我们将定义一个 Person 类。这是一个典型的可变对象，我们可以随意修改它的名字。
// 定义一个可变类 Person
public class Person {
// 字段可以是 private 的，但提供了修改途径
private String name;
// 构造函数初始化状态
public Person(String name) {
this.name = name;
}
// Getter 方法
public String getName() {
return name;
}
// Setter 方法：允许外部修改对象状态，这是可变对象的标志
public void setName(String newName) {
this.name = newName;
}
public static void main(String[] args) {
// 1. 创建对象，初始状态为 "John"
Person person = new Person("John");
System.out.println("初始名字: " + person.getName());
// 2. 修改对象状态
// 注意：我们没有创建新对象，只是改变了现有对象的内容
person.setName("Doe");
System.out.println("修改后名字: " + person.getName());
}
}
输出：
初始名字: John
修改后名字: Doe
关键点： 请注意 INLINECODE5e71aa10 方法。这是可变对象的灵魂所在。在多线程环境下，如果两个线程同时持有一个 INLINECODEf91392f6 对象的引用，其中一个线程调用了 setName，那么另一个线程读取到的名字就会突然变化。这就是可变对象带来的潜在风险：状态的不确定性。
#### 示例 2：创建一个标准的不可变类
现在，让我们看看如何设计一个不可变的 ImmutablePoint 类。这次，一旦点被创建，它的坐标就永远锁定了。
// 使用 final 关键字修饰类，防止被继承（防止子类破坏不可变性）
public final class ImmutablePoint {
// 字段必须是 private 和 final 的
private final int x;
private final int y;
// 构造函数：唯一能设置初始状态的地方
public ImmutablePoint(int x, int y) {
this.x = x;
this.y = y;
}
// 只有 Getter，没有 Setter
public int getX() {
return x;
}
public int getY() {
return y;
}
// 可选：重写 toString 方便打印
@Override
public String toString() {
return "(" + x + ", " + y + ")";
}
public static void main(String[] args) {
ImmutablePoint point = new ImmutablePoint(5, 10);
System.out.println("点的坐标: " + point.toString());
// 尝试修改？没有门路！这里没有 point.setX(20) 这种方法。
// 唯一的“改变”方式是创建一个新的对象
ImmutablePoint newPoint = new ImmutablePoint(20, 20);
System.out.println("新点的坐标: " + newPoint.toString());
}
}
输出：
点的坐标: (5, 10)
新点的坐标: (20, 20)
关键点： 我们不仅去掉了 INLINECODE21f17704，还将类和字段都设为了 INLINECODEbf4b035a。这就像给对象穿上了一层盔甲，确保了绝对的线程安全。任何持有 ImmutablePoint 引用的线程都不必担心坐标会被别人偷偷改掉。
#### 示例 3：进阶挑战 – 处理可变字段的不可变类
真正的挑战在于：如果一个不可变类中包含了一个本身是可变的字段（比如一个数组或集合），我们该怎么办？如果我们只是简单地存储引用，外部代码依然可以修改数组的内容，从而破坏不可变性！
错误的做法（非不可变）：
public class BrokenImmutable {
private final int[] data; // 引用是 final 的，但数组内容可变
public BrokenImmutable(int[] data) {
this.data = data; // 直接赋值引用！危险！
}
// ... 省略 getter
}
// 外部代码可以这样攻击：
// int[] arr = {1};
// BrokenImmutable obj = new BrokenImmutable(arr);
// arr[0] = 99; // obj 的内部状态被改了！
正确的做法（防御性拷贝）：
为了修复上述漏洞，我们需要在构造函数和 getter 中进行防御性拷贝。
import java.util.Arrays;
public final class SecureImmutable {
private final int[] data;
// 构造函数中进行防御性拷贝
public SecureImmutable(int[] data) {
// 不要直接使用 this.data = data;
// 而是创建一个副本
this.data = Arrays.copyOf(data, data.length);
}
// Getter 中也要进行防御性拷贝
public int[] getData() {
// 返回副本，防止外部通过返回的引用修改内部数据
return Arrays.copyOf(this.data, this.data.length);
}
public static void main(String[] args) {
int[] originalData = {1, 2, 3};
SecureImmutable secureObj = new SecureImmutable(originalData);
// 尝试修改原始数组
originalData[0] = 999;
// 打印对象内部数据
System.out.println("对象内部数据 (应为未修改): " + Arrays.toString(secureObj.getData()));
}
}
输出：
对象内部数据 (应为未修改): [1, 2, 3]
解析： 通过在构造时复制数据并存储副本，以及在获取数据时返回另一个副本，我们彻底切断了外部代码与内部状态的联系。这就是编写健壮不可变类的黄金法则。
关键区别总结：一张图看懂
让我们把这两种对象放在聚光灯下，做一个全方位的对比。
可变对象
:—
创建后可以更改状态（值）。
通常包含 Setter 和 Getter。
修改状态时不创建新对象（就地修改）。
不保证线程安全，需要额外的同步机制。
较低，不需要频繁创建新对象。
INLINECODE50025457, INLINECODEd8fb133f, INLINECODE5d4d30b3
最佳实践与性能优化
既然我们了解了这两种对象的优缺点，那么在实际项目中，我们该如何做出选择呢？这里有一些经验之谈。
#### 1. 默认选择不可变性
根据 Joshua Bloch 的经典著作《Effective Java》，我们的设计策略应该是：除非有充分的理由使用可变对象，否则优先使用不可变对象。
- 简单性： 不可变对象的状态只有一种，就是创建时的状态，这大大简化了代码的推理过程。
- 线程安全： 这是不可变对象最大的杀手锏。你不需要编写复杂的同步代码来保护不可变对象，因为它们根本不会被改变。这在高并发环境下是巨大的性能优势。
#### 2. 何时必须使用可变对象？
虽然不可变对象很好，但它们并不万能。在以下场景中，你必须使用可变对象：
- 频繁的修改操作： 比如你在构建一个复杂的字符串，或者在一个循环中频繁更新计算结果。如果使用 INLINECODEbc41eaef（不可变），每次 INLINECODEe6c4f192 操作都会生成一个新的 INLINECODE7edc324e 对象，造成大量的内存垃圾。这时，使用 INLINECODE98e7560a（可变）是明智的选择。
#### 3. 深入理解 String 的不可变性陷阱
让我们通过一个具体的例子来看看 String 的不可变性如何影响我们的代码逻辑。
public class StringDemo {
public static void main(String[] args) {
String s1 = "Hello";
String s2 = s1; // s2 和 s1 指向同一个 "Hello" 对象
s1 = s1 + " World"; // 这里发生了什么？
System.out.println("s1: " + s1);
System.out.println("s2: " + s2);
}
}
输出：
s1: Hello World
s2: Hello
解析：
很多初学者会以为 INLINECODE9dc783a6 也会变成 "Hello World"。但实际上，INLINECODE7b87b12a 是不可变的。当我们执行 INLINECODE25e54dcd 时，Java 并没有改变原来的 "Hello" 对象，而是创建了一个新的 "Hello World" 对象，并将 INLINECODE2c7dadd5 的引用指向了这个新对象。而 s2 依然指向原来的 "Hello" 对象。理解这一点对于避免 Java 编程中的逻辑错误至关重要。
#### 4. 构建不可变类的检查清单
当你需要自己设计一个不可变类时，请务必检查以下几点：
- 不要提供 Setter 方法。
- 将所有的字段声明为
private final。 - 确保类不能被继承（声明为
final类或构造器私有化）。 - 如果字段包含对可变对象的引用（如 INLINECODEb13b58ef, INLINECODE09cc11fb），必须进行防御性拷贝。
- 如果可变对象被传递给构造器，也要进行拷贝，而不是直接赋值。
总结
在 Java 的世界里，可变与不可变对象就像阴阳两面，相辅相成。不可变对象带给我们安全、简单和高效的并发性能，而可变对象则提供了灵活的状态管理和低开销的数据修改能力。
掌握它们之间的界限，知道何时使用哪一种工具，不仅能让你写出避免 BUG 的代码，更能让你的架构设计更加优雅。下一次，当你拿起键盘准备创建一个新类时，不妨先问问自己：“这个对象的状态真的需要改变吗？” 如果答案是否定的，那就勇敢地把它设计成不可变的吧！
希望这篇文章能帮助你彻底理清这两个核心概念。祝你编码愉快！