子类型对于参数化类型是不变的。即使严格来说，类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
}

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

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

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

// 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＞。

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

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

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

因此，假设有如下方法：

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兼容。。。。

我想说，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());