如何在Java中建模新旧Foo对象列表，避免意外误用？

你提到的封装列表类是可行方案之一，但并非唯一解，以下是几种更优或替代的实现方式：

1. 直接拆分新旧Foo类（最推荐） #

既然是两个版本的Foo数据结构，最根本的解决方式是将它们定义为不同的类，从类型层面彻底区分。这样方法参数的类型约束会直接阻止错误传入。

// 旧版本Foo
class OldFoo {
    private double someNum;
}

// 新版本Foo（可添加新字段或修改逻辑）
class NewFoo {
    private double someNum;
    // 比如新增字段：private String newField;
}

class NewFooRunner {
    // 仅接收新版本Foo的列表，编译期即可拦截旧版本传入
    public double runFoos(List<NewFoo> foos) {
        // 处理逻辑
        return 0.0;
    }
}

// 使用示例
List<OldFoo> oldFoos = new ArrayList<>();
List<NewFoo> newFoos = new ArrayList<>();
// runFoos(oldFoos); // 编译报错，无法传入

2. 标记接口+泛型包装类（兼容现有Foo类） #

如果无法修改现有Foo类的定义，可以通过标记接口配合泛型包装类，给不同版本的Foo实例打上类型标记，实现编译期校验。

// 空标记接口，仅用于区分版本
interface OldFooMarker {}
interface NewFooMarker {}

// 带类型标记的Foo包装类
class TaggedFoo<T> {
    private final Foo foo;

    public TaggedFoo(Foo foo) {
        this.foo = foo;
    }

    public Foo getFoo() {
        return foo;
    }
}

class NewFooRunner {
    // 仅接收带NewFooMarker标记的包装类列表
    public double runFoos(List<TaggedFoo<NewFooMarker>> foos) {
        // 处理逻辑：遍历取出Foo实例
        for (TaggedFoo<NewFooMarker> tagged : foos) {
            Foo foo = tagged.getFoo();
            // ...
        }
        return 0.0;
    }
}

// 使用示例
List<TaggedFoo<OldFooMarker>> oldFoos = new ArrayList<>();
oldFoos.add(new TaggedFoo<>(new Foo()));

List<TaggedFoo<NewFooMarker>> newFoos = new ArrayList<>();
newFoos.add(new TaggedFoo<>(new Foo()));

// runFoos(oldFoos); // 编译报错，类型不匹配

3. 封装列表容器类（你提到的方案） #

这种方式通过自定义容器类封装列表，利用容器类型区分新旧版本，同样能实现编译期校验。注意优化容器类的实现，比如添加不可变性保证：

class OldFoos {
    private final List<Foo> foos;

    public OldFoos(List<Foo> foos) {
        // 传入的列表做拷贝并转为不可变，防止外部修改内部状态
        this.foos = Collections.unmodifiableList(new ArrayList<>(foos));
    }

    public List<Foo> getFoos() {
        return foos;
    }
}

class NewFoos {
    private final List<Foo> foos;

    public NewFoos(List<Foo> foos) {
        this.foos = Collections.unmodifiableList(new ArrayList<>(foos));
    }

    public List<Foo> getFoos() {
        return foos;
    }
}

class NewFooRunner {
    public double runFoos(NewFoos foos) {
        List<Foo> newFooList = foos.getFoos();
        // 处理逻辑
        return 0.0;
    }
}

// 使用示例
OldFoos oldFoos = new OldFoos(new ArrayList<>());
NewFoos newFoos = new NewFoos(new ArrayList<>());
// runFoos(oldFoos); // 编译报错，类型不匹配

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