Java中如何设置对象成员为不可变？含深层成员及测试验证需求

好问题！这是不可变类设计里非常典型的“引用泄露”问题——你以为用了final修饰成员就安全了，但如果成员是可变对象，直接返回它的引用等于给了外部修改内部状态的钥匙。咱们拆解两个核心问题来解决：

一、怎么阻止通过getter修改对象成员（包括深层成员）？ #

核心思路就是绝对不泄露内部可变对象的直接引用，具体有三种常用方案：

1. 让成员类本身变成不可变类 #

这是最彻底的方案。如果你的Bar类设计成不可变的，那即使外部拿到它的引用，也没有任何方法能修改它的状态。

比如把Bar改成不可变：

// 不可变的Bar类：字段final、无setter、构造器初始化
class ImmutableBar {
    private final int value;
    
    public ImmutableBar(int value) {
        this.value = value;
    }
    
    // 只提供读取方法，没有修改方法
    public int getValue() {
        return value;
    }
}

class Foo {
    private final ImmutableBar bar;
    
    public Foo(ImmutableBar bar) {
        this.bar = bar; // 直接引用没问题，因为ImmutableBar不可变
    }
    
    public ImmutableBar getBar() {
        return bar; // 返回原引用也安全，外部改不了
    }
}

public class Main {
    public static void main(String[] args) {
        ImmutableBar bar = new ImmutableBar(10);
        Foo foo = new Foo(bar);
        
        // 编译错误！ImmutableBar没有setValue方法，根本没法修改
        // foo.getBar().setValue(20);
        
        System.out.println(foo.getBar().getValue()); // 输出10，状态稳定
    }
}

2. 构造和getter时做防御性拷贝 #

如果Bar必须是可变类（比如业务需求没法改成不可变），那就要在构造Foo的时候和返回Bar的时候都做拷贝，让外部拿到的是独立的副本，修改副本不会影响Foo内部的原对象。

示例代码：

class Bar {
    private int value;
    
    public Bar(int value) {
        this.value = value;
    }
    
    public void setValue(int value) {
        this.value = value;
    }
    
    public int getValue() {
        return value;
    }
    
    // 提供拷贝构造器，用于复制对象
    public Bar(Bar other) {
        this.value = other.getValue();
    }
}

class Foo {
    private final Bar bar;
    
    public Foo(Bar bar) {
        // 构造时不直接用传入的bar，而是拷贝一个新的
        this.bar = new Bar(bar);
    }
    
    public Bar getBar() {
        // getter返回的是原bar的拷贝，不是原引用
        return new Bar(bar);
    }
}

public class Main {
    public static void main(String[] args) {
        Bar bar = new Bar(10);
        Foo foo = new Foo(bar);
        
        // 修改的是getter返回的拷贝，和Foo内部的bar没关系
        foo.getBar().setValue(20);
        
        System.out.println(foo.getBar().getValue()); // 输出10，原状态未变
        System.out.println(bar.getValue()); // 输出10，原bar也没被修改
    }
}

3. 深层不可变：处理嵌套的可变成员 #

如果Bar里面还有可变的子成员（比如Bar包含一个Baz类，而Baz也是可变的），那就要做深拷贝——不仅拷贝Bar，还要拷贝它内部的所有可变子对象，确保每一层都不会泄露引用。

示例代码：

// 可变的Baz类
class Baz {
    private String name;
    
    public Baz(String name) {
        this.name = name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
    
    // 拷贝构造器
    public Baz(Baz other) {
        this.name = other.getName();
    }
}

// 包含Baz的Bar类，做深拷贝
class Bar {
    private Baz baz;
    
    public Bar(Baz baz) {
        // 构造时拷贝Baz，而不是直接引用
        this.baz = new Baz(baz);
    }
    
    public Baz getBaz() {
        // getter返回Baz的拷贝
        return new Baz(baz);
    }
}

class Foo {
    private final Bar bar;
    
    public Foo(Bar bar) {
        // 深拷贝Bar，包括它内部的Baz
        this.bar = new Bar(bar.getBaz());
    }
    
    public Bar getBar() {
        // 返回Bar的拷贝，内部的Baz也是拷贝
        return new Bar(bar.getBaz());
    }
}

public class Main {
    public static void main(String[] args) {
        Baz baz = new Baz("original");
        Bar bar = new Bar(baz);
        Foo foo = new Foo(bar);
        
        // 尝试修改深层成员
        foo.getBar().getBaz().setName("modified");
        
        // Foo内部的状态完全不受影响
        System.out.println(foo.getBar().getBaz().getName()); // 输出original
    }
}

二、不可变类能否包含可变类成员？ #

当然可以！但有一个严格的前提：必须绝对保证外部无法通过任何途径修改这个可变成员的状态。

换句话说，你要把这个可变成员完全封装起来：

• 构造时做深拷贝，避免外部传入的可变对象修改影响内部；
• getter方法返回不可变包装或者拷贝，不泄露原引用；
• 类内部也不能有任何修改这个可变成员的方法；
• 如果是集合类（比如ArrayList），可以用Collections.unmodifiableList()这类不可变包装器（注意：如果集合里的元素是可变的，还是要对元素做不可变处理）。

比如一个包含ArrayList的不可变类：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

class ImmutableFoo {
    private final List<String> items;
    
    public ImmutableFoo(List<String> items) {
        // 构造时拷贝传入的列表，避免外部修改影响内部
        this.items = new ArrayList<>(items);
    }
    
    public List<String> getItems() {
        // 返回不可变包装，外部只能读取，不能修改
        return Collections.unmodifiableList(items);
    }
}

public class Main {
    public static void main(String[] args) {
        List<String> original = new ArrayList<>();
        original.add("apple");
        ImmutableFoo foo = new ImmutableFoo(original);
        
        // 尝试修改返回的列表，会抛出UnsupportedOperationException
        // foo.getItems().add("banana");
        
        // 修改原列表也不影响foo内部的列表
        original.add("orange");
        System.out.println(foo.getItems()); // 输出[apple]
    }
}

总结一下：实现深层不可变的关键是切断外部对内部可变状态的所有访问路径，要么让成员本身不可变，要么通过拷贝、包装等手段隔离引用。不可变类完全可以包含可变成员，只要你能做到“封装到位，绝不泄露”。

内容的提问来源于stack exchange，提问作者Byeongdo Lee