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

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

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

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

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

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

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

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

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

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

让我们继续创建一个简化的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在编译时处理这个问题。

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

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