在 java 中防止外部持有可变对象引用的核心做法是:在构造器或访问方法中,对内部的可变状态(如 list、map、date)进行防御性拷贝(defensive copy),并在返回时再次拷贝。这样外部获得的引用与内部持有的引用指向不同的内存地址,外部对对象的修改不会影响内部状态。

为什么直接暴露引用会导致封装失效?
如果类内部维护了一个可变集合,并直接返回该集合的引用,外部代码就可以通过该引用直接修改集合内容,从而破坏类的不变量(Invariants)。例如,一个表示用户权限的类,如果直接返回权限列表,外部可以随意添加或删除权限,导致数据不一致。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class User {
private List<string> permissions;
public User(List<string> initialPermissions) {
// 1. 构造器中防御性拷贝
this.permissions = new ArrayList(initialPermissions);
}
// 错误做法:直接返回内部引用
public List<string> getPermissionsBad() {
return permissions;
}
// 正确做法:返回不可变视图或防御性拷贝
public List<string> getPermissionsGood() {
// 方案A:返回只读视图(推荐用于读取)
return Collections.unmodifiableList(permissions);
// 方案B:返回防御性拷贝(如果调用者需要修改副本且不影响内部)
// return new ArrayList(permissions);
}
}
// 测试验证
public class Main {
public static void main(String[] args) {
List<string> input = new ArrayList();
input.add("READ");
User user = new User(input);
// 尝试通过坏方法修改
List<string> badRef = user.getPermissionsBad();
badRef.add("WRITE"); // 内部状态被污染!
System.out.println(user.getPermissionsBad().size()); // 输出 2
// 尝试通过好方法修改
List<string> goodRef = user.getPermissionsGood();
try {
goodRef.add("ADMIN"); // 抛出 UnsupportedOperationException
} catch (UnsupportedOperationException e) {
System.out.println("修改失败,内部状态安全");
}
System.out.println(user.getPermissionsGood().size()); // 输出 1
}
}</string></string></string></string></string></string></string>
上述代码展示了两种常见场景。第一种是构造器接收外部传入的可变对象,如果不拷贝,外部后续修改传入的 input 列表,也会影响到 User 内部的状态。第二种是访问器方法,直接返回内部引用允许外部增删元素。使用 Collections.unmodifiableList 包装后,任何修改尝试都会抛出异常,从而保证内部数据的完整性。
如何处理嵌套的可变对象?
当内部状态包含嵌套的可变对象(如 List 或自定义对象列表)时,浅层防御性拷贝不足以保护内部状态。因为虽然外层容器被拷贝了,但容器内的元素仍然是共享引用。外部修改这些内部元素的属性,依然会破坏封装。

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
public class EventLog {
private List<event> events;
public EventLog(List<event> initialEvents) {
// 深层防御性拷贝:不仅拷贝列表,还要拷贝每个 Event 对象
this.events = new ArrayList();
for (Event e : initialEvents) {
this.events.add(new Event(e.getName(), e.getDate()));
}
}
public List<event> getEvents() {
// 返回不可变视图,同时确保内部 Event 也是独立的
return Collections.unmodifiableList(events);
}
}
class Event {
private String name;
private Date date;
public Event(String name, Date date) {
this.name = name;
// Date 也是可变的,必须拷贝
this.date = new Date(date.getTime());
}
public String getName() { return name; }
public Date getDate() { return new Date(date.getTime()); } // 同样需要防御性返回
}
// 验证
public class Main2 {
public static void main(String[] args) {
Date d = new Date();
List<event> input = new ArrayList();
input.add(new Event("Login", d));
EventLog log = new EventLog(input);
// 修改原始输入
d.setTime(0); // 修改时间戳
input.add(new Event("Logout", new Date()));
// 检查日志是否受影响
Event firstEvent = log.getEvents().get(0);
System.out.println(firstEvent.getDate().getTime()); // 应该保持初始值,而非 0
}
}</event></event></event></event>
在这个例子中,Event 类内部持有一个 Date 对象。Date 是可变的,因此 Event 的构造器和 getDate() 方法都需要进行防御性拷贝。如果 Event 没有拷贝 Date,那么即使 EventLog 做了深层拷贝,外部仍然可以通过获取到的 Event 对象修改其内部的 Date,进而影响其他依赖该时间的逻辑。这体现了防御性编程的递归性质:所有层级上的可变对象都必须被隔离。
基于程序中某个输入、条件或结果的具体问题
在上面的 EventLog 示例中,如果我们传入一个空的 initialEvents 列表,或者传入 null,程序的行为会如何?
public class Main3 {
public static void main(String[] args) {
// 情况1:空列表
List<event> emptyList = new ArrayList();
EventLog log1 = new EventLog(emptyList);
System.out.println(log1.getEvents().isEmpty()); // true
// 情况2:null 输入
try {
EventLog log2 = new EventLog(null);
} catch (NullPointerException e) {
System.out.println("NullInput: 抛出 NullPointerException");
}
}
}</event>
如果构造器中没有对 null 进行检查,传入 null 会导致 NullPointerException。在实际开发中,通常建议在构造器开头显式检查参数是否为 null,并抛出带有明确信息的 IllegalArgumentException 或 NullPointerException,以便快速定位问题。例如:if (initialPermissions == null) throw new NullPointerException("Permissions cannot be null");。这种检查属于防御性编程的另一层面:输入验证,它与防御性拷贝共同构成了完整的封装保护机制。
Java免费学习笔记:立即使用
解锁 Java 大师之旅:从入门到精通的终极指南











