java 封装中,使用 getter 返回不可变对象的核心做法是:在 getter 方法中返回内部可变字段的副本(深拷贝或浅拷贝),而不是直接返回该字段的引用。这样外部代码获取到的是数据的快照,对返回对象的任何修改都不会影响类内部的原始状态,从而保证了封装性和数据的安全性。

为什么直接返回引用会导致封装失效
如果 getter 直接返回内部可变对象的引用,外部代码就可以通过该引用修改对象内部的状态,破坏了封装性。例如,当内部字段是一个 List 时,直接返回它会让调用者能够向列表中添加或删除元素,导致类的内部状态被意外改变。

import java.util.ArrayList;
import java.util.List;
public class UnsafeExample {
private List<string> items = new ArrayList();
public UnsafeExample() {
items.add("Item1");
items.add("Item2");
}
// 危险的做法:直接返回内部列表的引用
public List<string> getItems() {
return items;
}
public static void main(String[] args) {
UnsafeExample example = new UnsafeExample();
// 外部直接修改了内部状态
example.getItems().add("Item3");
System.out.println(example.getItems()); // 输出: [Item1, Item2, Item3]
}
}</string></string>
上述代码中,getItems() 方法直接返回了私有字段 items 的引用。在 main 方法中,调用者通过 example.getItems().add("Item3") 成功修改了 UnsafeExample 内部的列表内容。这证明了直接返回引用会破坏封装,因为外部代码拥有了对内部可变状态的直接访问权限。
如何正确实现不可变返回
正确的做法是在 getter 中返回一个副本。对于集合类型,可以使用 new ArrayList(original) 进行浅拷贝;对于包含可变对象的集合,需要进行深拷贝。这样,外部代码操作的是副本,而内部状态保持不变。
使用 Husky 将 pre-commit、pre-push 和 commit-msg 检查集成到仓库中,以便代理和开发人员在更改离开工作站之前运行相同的本地防护措施。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class SafeExample {
private List<string> items = new ArrayList();
public SafeExample() {
items.add("Item1");
items.add("Item2");
}
// 安全做法1:返回不可变视图
public List<string> getItemsUnmodifiable() {
return Collections.unmodifiableList(items);
}
// 安全做法2:返回副本
public List<string> getItemsCopy() {
return new ArrayList(items);
}
public static void main(String[] args) {
SafeExample example = new SafeExample();
// 尝试修改不可变视图会抛出异常
try {
example.getItemsUnmodifiable().add("Item3");
} catch (UnsupportedOperationException e) {
System.out.println("Cannot modify unmodifiable list");
}
// 修改副本不影响内部状态
List<string> copy = example.getItemsCopy();
copy.add("Item3");
System.out.println(example.getItemsCopy()); // 输出: [Item1, Item2]
System.out.println(copy); // 输出: [Item1, Item2, Item3]
}
}</string></string></string></string>
在 SafeExample 中,getItemsUnmodifiable() 使用 Collections.unmodifiableList() 返回一个只读视图,任何修改尝试都会抛出 UnsupportedOperationException。getItemsCopy() 则返回一个新的 ArrayList 实例,它是内部列表的副本。在 main 方法中,修改副本不会影响原始的内部状态,确保了封装性。
基于程序中某个输入、条件或结果的具体问题
当内部字段是自定义的可变对象(如 User 类)时,浅拷贝不足以保证不可变性,必须进行深拷贝。否则,虽然返回了新的集合引用,但集合中的元素仍然是原始对象的引用,外部代码仍可通过这些引用修改内部状态。
import java.util.ArrayList;
import java.util.List;
public class User {
private String name;
private int age;
public User(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public int getAge() { return age; }
public void setAge(int age) { this.age = age; }
}
public class DeepCopyExample {
private List<user> users = new ArrayList();
public DeepCopyExample() {
users.add(new User("Alice", 30));
users.add(new User("Bob", 25));
}
// 错误的浅拷贝:返回的列表中元素仍是原引用
public List<user> getUsersShallowCopy() {
return new ArrayList(users);
}
// 正确的深拷贝:创建新的User对象
public List<user> getUsersDeepCopy() {
List<user> copy = new ArrayList();
for (User user : users) {
copy.add(new User(user.getName(), user.getAge()));
}
return copy;
}
public static void main(String[] args) {
DeepCopyExample example = new DeepCopyExample();
// 浅拷贝的问题
List<user> shallowCopy = example.getUsersShallowCopy();
shallowCopy.get(0).setName("Charlie"); // 修改了内部状态!
System.out.println(example.getUsersShallowCopy().get(0).getName()); // 输出: Charlie
// 深拷贝的正确性
List<user> deepCopy = example.getUsersDeepCopy();
deepCopy.get(0).setName("David"); // 不影响内部状态
System.out.println(example.getUsersDeepCopy().get(0).getName()); // 输出: Alice
}
}</user></user></user></user></user></user>
在 DeepCopyExample 中,getUsersShallowCopy() 仅复制了列表结构,但列表中的 User 对象引用与内部相同。因此,修改副本中的用户名称会影响内部状态。而 getUsersDeepCopy() 创建了新的 User 对象,确保外部修改不会影响内部状态。这展示了在处理复杂对象时,深拷贝的必要性。
Java免费学习笔记:立即使用
解锁 Java 大师之旅:从入门到精通的终极指南










