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

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

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

您要查找的是所谓的协变类型参数。这意味着，如果在方法中可以用一种类型的对象替换另一种类型（例如，Animal可以替换为Dog），那么同样的情况也适用于使用这些对象的表达式（因此List＜Animal＞可以替换为List＜Dog＞）。问题是，一般来说，协方差对于可变列表来说是不安全的。假设您有一个List<Dog>，并且它被用作List<Animal>。当你试图将一只猫添加到这个列表<动物>中时会发生什么？自动允许类型参数为协变会破坏类型系统。

添加语法以允许将类型参数指定为协变将是有用的，这避免了？在方法声明中扩展了Foo，但这确实增加了额外的复杂性。

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

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

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

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

为了理解这个问题，比较数组是很有用的。

List<Dog>不是List<Animal>的子类。但狗[]是动物[]的子类。

数组是可具体化和协变的。可重用意味着它们的类型信息在运行时完全可用。因此，数组提供运行时类型安全性，但不提供编译时类型安全。

    // All compiles but throws ArrayStoreException at runtime at last line
    Dog[] dogs = new Dog[10];
    Animal[] animals = dogs; // compiles
    animals[0] = new Cat(); // throws ArrayStoreException at runtime

对于泛型，情况也是如此：泛型被删除且不变。因此，泛型不能提供运行时类型安全，但它们提供编译时类型安全。在下面的代码中，如果泛型是协变的，则可能在第3行造成堆污染。

    List<Dog> dogs = new ArrayList<>();
    List<Animal> animals = dogs; // compile-time error, otherwise heap pollution
    animals.add(new Cat());

我看到这个问题已经被回答了很多次，只想在同一个问题上输入我的意见。

让我们继续创建一个简化的Animal类层次结构。

abstract class Animal {
    void eat() {
        System.out.println("animal eating");
    }
}

class Dog extends Animal {
    void bark() { }
}

class Cat extends Animal {
    void meow() { }
}

现在让我们看看我们的老朋友Arrays，我们知道它隐式支持多态性-

class TestAnimals {
    public static void main(String[] args) {
        Animal[] animals = {new Dog(), new Cat(), new Dog()};
        Dog[] dogs = {new Dog(), new Dog(), new Dog()};
        takeAnimals(animals);
        takeAnimals(dogs);
    }

    public void takeAnimals(Animal[] animals) {
        for(Animal a : animals) {
            System.out.println(a.eat());
        }
    }   
}

该类编译良好，当我们运行上面的类时，我们得到输出

animal eating
animal eating
animal eating
animal eating
animal eating
animal eating

这里需要注意的是，takeAnimals（）方法被定义为接受Animal类型的任何东西，它可以接受Animal类型的数组，也可以接受Dog类型的数组。这就是多态性的作用。

现在让我们对泛型使用相同的方法，

现在假设我们稍微调整一下代码，使用ArrayList而不是Arrays-

class TestAnimals {
    public static void main(String[] args) {
        ArrayList<Animal> animals = new ArrayList<Animal>();
        animals.add(new Dog());
        animals.add(new Cat());
        animals.add(new Dog());
        takeAnimals(animals);
    }

    public void takeAnimals(ArrayList<Animal> animals) {
        for(Animal a : animals) {
            System.out.println(a.eat());
        }
    }   
}

上面的类将编译并生成输出-

animal eating
animal eating
animal eating
animal eating
animal eating
animal eating

所以我们知道这是可行的，现在让我们稍微调整一下这个类，使其以多态的方式使用Animal类型-

class TestAnimals {
    public static void main(String[] args) {
        ArrayList<Animal> animals = new ArrayList<Animal>();
        animals.add(new Dog());
        animals.add(new Cat());
        animals.add(new Dog());

        ArrayList<Dog> dogs = new ArrayList<Dog>();
        takeAnimals(animals);
        takeAnimals(dogs);
    }

    public void takeAnimals(ArrayList<Animal> animals) {
        for(Animal a : animals) {
            System.out.println(a.eat());
        }
    }   
}

看起来编译上面的类应该没有问题，因为takeAnimals（）方法被设计为接受Animal和Dog-is-Animal类型的任何ArrayList，因此它不应该成为交易破坏者。

但是，不幸的是，编译器抛出了一个错误，不允许我们将Dog ArrayList传递给期望Animal ArrayList的变量。

你问为什么？

因为想象一下，如果JAVA允许将Dog ArrayList-dogs-放入Animal ArrayList中-animals-然后在takeAnimals（）方法中，有人会这样做-

animals.add(new Cat());

认为这应该是可行的，因为理想情况下它是一个Animal ArrayList，您应该能够将任何猫添加到其中，作为cat-is-also-Animal，但实际上您将一个Dog类型的ArrayList传递给了它。

所以，现在您必须想到，数组也应该发生同样的情况。你这样想是对的。

如果有人试图用Arrays做同样的事情，那么Arrays也会抛出一个错误，但Arrays在运行时处理这个错误，而ArrayList在编译时处理这个问题。

我认为，其他答案中提到的一点是

List＜Dog＞不是Java中的List＜Animal＞

这也是事实

狗的列表是英文的动物列表（在合理的解释下）

OP的直觉运作方式——当然这是完全有效的——是后一句话。然而，如果我们运用这种直觉，我们得到的语言在其类型系统中不是Java风格的：假设我们的语言确实允许将猫添加到我们的狗列表中。这意味着什么？这意味着该列表不再是狗的列表，而仅仅是动物的列表。还有一张哺乳动物的列表和一张四足动物的列表。

换一种说法：Java中的List＜Dog＞在英语中并不意味着“一个狗的列表”，它的意思是“一个只有狗的列表。”。

更一般地说，OP的直觉倾向于一种语言，在这种语言中，对对象的操作可以改变其类型，或者更确切地说，对象的类型是其值的（动态）函数。