另一个解决方案是建立一个新的列表

List<Dog> dogs = new ArrayList<Dog>(); 
List<Animal> animals = new ArrayList<Animal>(dogs);
animals.add(new Cat());

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

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

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

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

不，列表＜狗＞不是列表＜动物＞。考虑一下你可以用列表＜动物＞做什么——你可以在其中添加任何动物……包括一只猫。现在，你能在一窝小狗中加入一只猫吗？绝对不是。

// 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?

突然你有一只非常困惑的猫。

现在，您不能将猫添加到列表<？扩展Animal>，因为你不知道它是List＜Cat＞。您可以检索一个值并知道它将是一个Animal，但不能添加任意的Animal。列表<？super Animal>-在这种情况下，您可以安全地将Animal添加到其中，但您不知道可能从中检索到什么，因为它可能是List＜Object＞。

这里给出的答案并不能完全说服我，所以我再举一个例子。

public void passOn(Consumer<Animal> consumer, Supplier<Animal> supplier) {
    consumer.accept(supplier.get());
}

听起来不错，不是吗？但你只能通过动物消费者和供应商。如果你有哺乳动物的消费者，但鸭子的供应商，尽管它们都是动物，但它们不应该适合。为了禁止这种行为，增加了额外的限制。

我们必须定义我们使用的类型之间的关系，而不是上述内容。

例如。，

public <A extends Animal> void passOn(Consumer<A> consumer, Supplier<? extends A> supplier) {
    consumer.accept(supplier.get());
}

确保我们只能使用为消费者提供正确类型对象的供应商。

OTOH，我们也可以

public <A extends Animal> void passOn(Consumer<? super A> consumer, Supplier<A> supplier) {
    consumer.accept(supplier.get());
}

我们的方向相反：我们定义供应商的类型，并限制其可以投放给消费者。

我们甚至可以做到

public <A extends Animal> void passOn(Consumer<? super A> consumer, Supplier<? extends A> supplier) {
    consumer.accept(supplier.get());
}

其中，有了“生活”->“动物”->“哺乳动物”->“狗”、“猫”等直观关系，我们甚至可以将“哺乳动物”放入“生活”消费者，但不能将“字符串”放入“生命”消费者。

这种行为的基本逻辑是泛型遵循类型擦除机制。因此，在运行时，您无法识别集合的类型，而不像阵列中没有这样的擦除过程。回到你的问题。。。

因此，假设有如下方法：

add(List<Animal>){
    //You can add List<Dog or List<Cat> and this will compile as per rules of polymorphism
}

现在，若java允许调用者将List of type Animal添加到此方法中，那个么您可能会将错误的内容添加到集合中，并且在运行时它也会由于类型擦除而运行。而在数组的情况下，您将获得此类场景的运行时异常。。。

因此，本质上，这种行为的实现是为了避免将错误的东西添加到集合中。现在我相信类型删除的存在是为了与没有泛型的遗留java兼容。。。。

让我们以JavaSE教程为例

public abstract class Shape {
    public abstract void draw(Canvas c);
}

public class Circle extends Shape {
    private int x, y, radius;
    public void draw(Canvas c) {
        ...
    }
}

public class Rectangle extends Shape {
    private int x, y, width, height;
    public void draw(Canvas c) {
        ...
    }
}

因此，为什么狗（圆圈）的列表不应被视为动物（形状）的列表，是因为这种情况：

// drawAll method call
drawAll(circleList);


public void drawAll(List<Shape> shapes) {
   shapes.add(new Rectangle());    
}

因此，Java“架构师”有两个选项可以解决这个问题：

不要认为子类型是隐式的，它是父类型，并给出编译错误，就像现在发生的那样将子类型视为它的父类型，并在编译“add”方法时进行限制（因此在drawAll方法中，如果要传递圆的列表（形状的子类型），编译器应该检测到这一点，并用编译错误限制您这样做）。

出于明显的原因，他们选择了第一条路。