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

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

子类型对于参数化类型是不变的。即使严格来说，类Dog是Animal的子类型，但参数化类型List＜Dog＞不是List＜Animal＞的子类型。相反，协变子类型由数组使用，因此数组类型狗[]是动物[]的一个亚型。

不变的子类型确保不违反Java强制的类型约束。考虑@Jon Skeet给出的以下代码：

List<Dog> dogs = new ArrayList<Dog>(1);
List<Animal> animals = dogs;
animals.add(new Cat()); // compile-time error
Dog dog = dogs.get(0);

正如@Jon Skeet所说，这段代码是非法的，因为否则它会违反类型约束，在狗期望的时候返回一只猫。

将上述代码与数组的类似代码进行比较是有指导意义的。

Dog[] dogs = new Dog[1];
Object[] animals = dogs;
animals[0] = new Cat(); // run-time error
Dog dog = dogs[0];

该代码是合法的。但是，引发数组存储异常。数组在运行时携带其类型，JVM可以这样强制协变子类型的类型安全性。

为了进一步理解这一点，让我们看一下javap生成的字节码：

import java.util.ArrayList;
import java.util.List;

public class Demonstration {
    public void normal() {
        List normal = new ArrayList(1);
        normal.add("lorem ipsum");
    }

    public void parameterized() {
        List<String> parameterized = new ArrayList<>(1);
        parameterized.add("lorem ipsum");
    }
}

使用命令javap-c演示，这将显示以下Java字节码：

Compiled from "Demonstration.java"
public class Demonstration {
  public Demonstration();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public void normal();
    Code:
       0: new           #2                  // class java/util/ArrayList
       3: dup
       4: iconst_1
       5: invokespecial #3                  // Method java/util/ArrayList."<init>":(I)V
       8: astore_1
       9: aload_1
      10: ldc           #4                  // String lorem ipsum
      12: invokeinterface #5,  2            // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
      17: pop
      18: return

  public void parameterized();
    Code:
       0: new           #2                  // class java/util/ArrayList
       3: dup
       4: iconst_1
       5: invokespecial #3                  // Method java/util/ArrayList."<init>":(I)V
       8: astore_1
       9: aload_1
      10: ldc           #4                  // String lorem ipsum
      12: invokeinterface #5,  2            // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
      17: pop
      18: return
}

观察方法体的翻译代码是否相同。编译器通过删除来替换每个参数化类型。此属性至关重要，这意味着它不会破坏向后兼容性。

总之，参数化类型的运行时安全性是不可能的，因为编译器通过删除来替换每个参数化类型。这使得参数化类型只不过是语法糖。

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

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());

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

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

这也是事实

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

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

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

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

问题已正确识别为与差异有关，但详细信息不正确。纯函数列表是协变数据函子，这意味着如果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_（计算机科学）

List＜Dog＞不是List＜Animal＞的原因是，例如，您可以将猫插入List＜Animate＞，但不能插入List＜Dog>。。。在可能的情况下，可以使用通配符使泛型更具可扩展性；例如，从List＜Dog＞中读取与从List＜Animal＞中读取类似，但不是写入。

《Java语言中的泛型》和《Java教程》中的“泛型”一节对为什么某些事物是多态的或不多态的或允许使用泛型进行了非常好、深入的解释。