问题已正确识别为与差异有关，但详细信息不正确。纯函数列表是协变数据函子，这意味着如果Sub类型是Super的子类型，那么Sub列表绝对是Super列表的子类型。

然而，列表的可变性并不是这里的基本问题。问题是总体上的可变性。这个问题是众所周知的，被称为协方差问题，我认为它是卡斯塔尼亚首先发现的，它完全彻底地破坏了作为一个通用范式的对象定向。这是基于Cardelli和Reynolds之前建立的方差规则。

有点过于简单化，让我们将T型对象B分配给T型对象A作为突变。这不失一般性：a的突变可以写成a=f（a），其中f:T->T。当然，问题是，虽然函数在其共域中是协变的，但它们在其域中是逆变的，但通过赋值，域和共域是相同的，因此赋值是不变的！

因此，概括而言，亚型不能突变。但是对象定向突变是根本的，因此对象定向本质上是有缺陷的。

这里有一个简单的例子：在纯函数设置中，对称矩阵显然是一个矩阵，它是一个子类型，没有问题。现在，让我们在矩阵中添加一项功能，即在坐标（x，y）处设置一个元素，规则是其他元素不变。现在对称矩阵不再是一个子类型，如果你改变了（x，y），你也改变了（y，x）。函数运算是delta:Sym->Mat，如果你改变对称矩阵的一个元素，你会得到一个一般的非对称矩阵。因此，如果在Mat中包含“更改一个元素”方法，Sym不是子类型。事实上几乎肯定没有合适的亚型。

简单地说，如果你有一个通用的数据类型，其中包含大量的变异器，这些变异器利用了它的通用性，你可以确定任何适当的子类型都不可能支持所有这些变异：如果可以，它将与超类型一样通用，与“适当”子类型的规范相反。

事实上，Java阻止了可变列表的子类型化，这并不能解决真正的问题：几十年前，当Java受到质疑时，为什么要使用面向对象的垃圾呢？？

无论如何，这里有一个合理的讨论：

https://en.wikipedia.org/wiki/Covariance_and_contravariance_（计算机科学）

答案和其他答案都是正确的。我将用我认为会有帮助的解决方案来补充这些答案。我认为这在编程中经常出现。需要注意的一点是，对于集合（列表、集合等），主要问题是添加到集合。这就是问题所在。即使移除也可以。

在大多数情况下，我们可以使用集合<？扩展T>而不是集合<T>，这应该是首选。然而，我发现这样做并不容易。关于这是否始终是最好的做法，这是一个值得争论的问题。我在这里介绍一个类DownCastCollection，它可以转换集合<？将T>扩展到集合<T>（我们可以为List、Set、NavigableSet等定义类似的类），以便在使用标准方法时使用。下面是一个如何使用它的示例（在这种情况下，我们也可以使用Collection<？extendsObject>，但我保持简单，以说明使用DownCastCollection。

/**Could use Collection<? extends Object> and that is the better choice. 
* But I am doing this to illustrate how to use DownCastCollection. **/

public static void print(Collection<Object> col){  
    for(Object obj : col){
    System.out.println(obj);
    }
}
public static void main(String[] args){
  ArrayList<String> list = new ArrayList<>();
  list.addAll(Arrays.asList("a","b","c"));
  print(new DownCastCollection<Object>(list));
}

现在开始上课：

import java.util.AbstractCollection;
import java.util.Collection;
import java.util.Iterator;
import java.util.NoSuchElementException;

public class DownCastCollection<E> extends AbstractCollection<E> implements Collection<E> {
private Collection<? extends E> delegate;

public DownCastCollection(Collection<? extends E> delegate) {
    super();
    this.delegate = delegate;
}

@Override
public int size() {
    return delegate ==null ? 0 : delegate.size();
}

@Override
public boolean isEmpty() {
    return delegate==null || delegate.isEmpty();
}

@Override
public boolean contains(Object o) {
    if(isEmpty()) return false;
    return delegate.contains(o);
}
private class MyIterator implements Iterator<E>{
    Iterator<? extends E> delegateIterator;

    protected MyIterator() {
        super();
        this.delegateIterator = delegate == null ? null :delegate.iterator();
    }

    @Override
    public boolean hasNext() {
        return delegateIterator != null && delegateIterator.hasNext();
    }

    @Override
    public  E next() {
        if(!hasNext()) throw new NoSuchElementException("The iterator is empty");
        return delegateIterator.next();
    }

    @Override
    public void remove() {
        delegateIterator.remove();

    }

}
@Override
public Iterator<E> iterator() {
    return new MyIterator();
}



@Override
public boolean add(E e) {
    throw new UnsupportedOperationException();
}

@Override
public boolean remove(Object o) {
    if(delegate == null) return false;
    return delegate.remove(o);
}

@Override
public boolean containsAll(Collection<?> c) {
    if(delegate==null) return false;
    return delegate.containsAll(c);
}

@Override
public boolean addAll(Collection<? extends E> c) {
    throw new UnsupportedOperationException();
}

@Override
public boolean removeAll(Collection<?> c) {
    if(delegate == null) return false;
    return delegate.removeAll(c);
}

@Override
public boolean retainAll(Collection<?> c) {
    if(delegate == null) return false;
    return delegate.retainAll(c);
}

@Override
public void clear() {
    if(delegate == null) return;
        delegate.clear();

}

}

我想说，Generics的全部观点是它不允许这样做。考虑数组的情况，它确实允许这种类型的协方差：

  Object[] objects = new String[10];
  objects[0] = Boolean.FALSE;

该代码编译良好，但抛出运行时错误（第二行中的java.lang.ArrayStoreException:java.lang.Boolean）。它不是类型安全的。Generics的目的是增加编译时类型安全性，否则您可以只使用没有泛型的普通类。

现在有些时候你需要更加灵活，这就是为什么？超级班和？扩展类用于。前者是当您需要插入到类型Collection中时（例如），后者是当需要以类型安全的方式从中读取时。但同时做到这两个的唯一方法是拥有一种特定的类型。

其他人已经很好地解释了为什么不能将后代列表转换为超类列表。

然而，许多人访问这个问题以寻求解决方案。

因此，自Java版本10以来，该问题的解决方案如下：

（注：S=超类）

List<S> supers = List.copyOf( descendants );

如果完全安全，则此函数将执行强制转换，如果强制转换不安全，则该函数将执行复制。

有关深入解释（考虑到此处其他答案提到的潜在陷阱），请参阅相关问题和我2022年的答案：https://stackoverflow.com/a/72195980/773113

我们还应该考虑编译器如何威胁泛型类：每当我们填充泛型参数时，“实例化”一个不同的类型。

因此，我们有ListOfAnimal、ListOfDog、ListOfCat等，它们是不同的类，当我们指定泛型参数时，最终由编译器“创建”。这是一个扁平的层次结构（实际上关于List根本不是一个层次结构）。

在泛型类的情况下，协方差没有意义的另一个论点是，基本上所有类都是相同的-都是List实例。通过填充泛型参数来专门化List并不会扩展类，它只会使其适用于特定的泛型参数。

关于Jon Skeet的回答，他使用了以下示例代码：

// Illegal code - because otherwise life would be Bad
List<Dog> dogs = new ArrayList<Dog>(); // ArrayList implements List
List<Animal> animals = dogs; // Awooga awooga
animals.add(new Cat());
Dog dog = dogs.get(0); // This should be safe, right?

在最深层次上，这里的问题是狗和动物共享一个参考。这意味着一种方法是复制整个列表，这将打破引用相等：

// This code is fine
List<Dog> dogs = new ArrayList<Dog>();
dogs.add(new Dog());
List<Animal> animals = new ArrayList<>(dogs); // Copy list
animals.add(new Cat());
Dog dog = dogs.get(0);   // This is fine now, because it does not return the Cat

在调用List＜Animal＞animals＝new ArrayList＜＞（狗）；后；，您随后不能将动物直接分配给狗或猫：

// These are both illegal
dogs = animals;
cats = animals;

因此，您不能将错误的Animal子类型放入列表中，因为没有错误的子类型--任何子类型的对象？扩展动物可以添加到动物。

显然，这改变了语义，因为动物和狗的列表不再共享，所以添加到一个列表不会添加到另一个列表中（这正是您想要的，以避免将猫添加到只应包含狗对象的列表中的问题）。此外，复制整个列表可能效率低下。然而，通过打破引用相等性，这确实解决了类型等价问题。