如何分配列表<？将 BaseClass> 扩展到 List<BaseClass>

Question

拥有

class BaseClass implements IData ();
class ChildClassA() extends BaseClass;
class ChildClassB() extends BaseClass;

因为做不到

List<BaseClass> aList = new ArrayList<ChildClassA>()

所以有一个

List<? extends IData> aList 
for pointint to either 
    ArrayList<ChildClassA>(),  
or 
    ArrayList<ChildClassB>()

aList 是由其他路由在运行时构建的，并且该部分代码具有从aList 中获取List<IData> 的功能

问题是List<? extends IData> aList 是指向ArrayList<ChildClassA>() 还是ArrayList<ChildClassB>()，

可以ListData<IData> outputList = (List<IData>) aList吗？如下所示：

（似乎它正在工作，但不确定除了强制转换之外是否有更好的方法来分配泛型数组。）

编辑：List<IData> outputList 的输出仅供只读使用（不可变），没有插入/删除，它只会迭代 IData 以对 IData 的真正含义做出反应。

List<? extends IData> aList =  new ArrayList<ChildClassA>();
ListData<IData> outputList = (List<IData>)aList

List<? extends IData> aList =  new ArrayList<ChildClassB>();
ListData<IData> outputList = (List<IData>)aList

Answer 1

tl;dr 使用Collections#unmodifiableList：

List<IData> outputList = Collections.unmodifiableList(aList);

有关此主题的更多信息，您可能需要熟悉PECS 原则。

---

不可能，因为这两种类型不兼容。

List<BaseClass> 就是它所声明的，BaseClass 对象的列表。更准确地说，它做了两个保证：

• 从中检索的对象可分配给BaseClass
• 可分配给BaseClass 的每个对象都可以添加到其中（不能添加其他对象）

List<? extends BaseClass> 是一个更宽松的声明。准确地说，它根本不做二次保证。然而，不仅保证消失了，而且现在不可能向其中添加项目，因为列表的确切泛型类型是未定义的。它甚至可能在运行时针对同一个列表声明（不是同一个列表对象）发生变化。

因此，List<? extends BaseClass> 不能分配给 List<BaseClass>，因为后者保证第一个无法实现。

---

实际上，考虑以下方法：

public List<BaseClass> makeList() {
    // TODO implement method
    return null;
}

如果有人实现了这个方法，返回一个List<? extends BaseClass>，一个使用这个方法的客户端将无法向它添加项目，尽管它的声明另有说明。

因此，这样的赋值会导致编译错误。

要解决示例问题，可以在方法中添加松散声明：

public List<? extends BaseClass> makeList() {
    // TODO implement method
    return null;
}

这将向每个客户端发出信号，从该方法返回的列表不用于向其添加项目。

---

现在让我们回到您的用例。在我看来，最合适的解决方法是改写该功能

从 aList 中获取一个 List。

目前看来它被声明为

public void useList(List<BaseClass> list);

但由于它不会将项目添加到列表中，因此应将其声明为

public void useList(List<? extends BaseClass> list);

但是，如果该方法是当前不可更改的 API 的一部分，您仍然可以这样做：

List<? extends BaseClass> list;
....
List<BaseClass> tmp = Collections.unmodifiableList(list);
useList(tmp);

Answer 2

不，不安全。

在该转换之后，将应该只包含ChildClassA 类型元素、另一个子类型ChildClassB 类型的元素添加到列表中是合法的，反之亦然。

我们可以稍微简化一下您的代码，以便更清楚地说明为什么不允许这样做：

List<ChildClassA> aList =  new ArrayList<ChildClassA>();
aList.add(a1);
aList.add(a2);
//...
List<IData> iDataList = (List<IData>) aList;
iDataList.add(b1);
iDataList.add(b2);
//...
for (ChildClassA a : aList) {
   // a some point a is going to be assigned b1 or b2 and they results in cast
   // exception.
}

注意iDataList 引用了与aList 完全相同的列表对象。 如果允许该转换，那么您将能够向aList 添加不是ChildClassA 实例的元素。

最好的解决方案是细节。

如果问题是第三方库需要 List<IData> 类型的引用，并且只要它仅供阅读，您就可以使用 Collections.unmodifiableList 返回的不可修改代理：

import java.util.Collections;
//...
final List<ChildClassA> aList = new ArrayList<>();
//... add stuff to aList
final List<IData> readOnlyIDataList = Collections.unmodifiableList(aList); 
//... read only access operations readOnlyIDataList