列表<狗>是列表<动物>的子类吗？为什么Java泛型不是隐式多态的？

不，List<Dog>是没有是List<Animal>。考虑一下你可以用List<Animal>做什么——你可以在里面添加任何动物……包括一只猫。现在，你能在一窝小狗上添加一只猫吗？绝对不行。

// Illegal code - because otherwise life would be BadList<Dog> dogs = new ArrayList<Dog>(); // ArrayList implements ListList<Animal> animals = dogs; // Awooga awoogaanimals.add(new Cat());Dog dog = dogs.get(0); // This should be safe, right?

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

现在，您可以不能将Cat添加到List<? extends Animal>，因为您不知道它是List<Cat>。您可以检索一个值并知道它将是Animal，但您不能添加任意动物。List<? super Animal>则相反-在这种情况下，您可以安全地将Animal添加到它，但您不知道可能从中检索到什么，因为它可能是List<Object>。

你要找的叫做协变类型参数。这意味着如果一种类型的对象可以在方法中替换另一种类型的对象（例如，Animal可以替换为Dog），同样的情况也适用于使用这些对象的表达式（所以List<Animal>可以替换为List<Dog>）。问题是协方差通常对可变列表来说是不安全的。假设你有一个List<Dog>，它被用作List<Animal>。当你试图向这个List<Animal>添加一个Cat时，会发生什么，这实际上是一个List<Dog>？自动允许类型参数为协变打破了类型系统。

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

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

Java语言中的泛型和Java教程中的泛型部分有一个非常好的，深入的解释，为什么有些东西是多态的或不允许泛型。

我会说泛型的全部意义在于它不允许这样做。考虑数组的情况，它确实允许这种类型的协方差：

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

这段代码编译得很好，但会抛出一个运行时错误（第二行中的java.lang.ArrayStoreException: java.lang.Boolean）。它不是类型安全的。泛型的重点是添加编译时类型安全，否则你可以坚持使用没有泛型的普通类。

现在有些时候你需要更加灵活，这就是? super Class和? extends Class的作用。前者是当你需要插入类型Collection（例如）时，后者是当你需要以类型安全的方式从中读取时。但同时做到这两者的唯一方法是拥有一个特定的类型。

这种行为的基本逻辑是Generics遵循类型擦除机制。因此，在运行时，你无法识别collection的类型，而arrays没有这种擦除过程。所以回到你的问题…

所以假设有下面给出的方法：

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

现在，如果java允许调用者将动物类型的List添加到此方法，那么您可能会将错误的东西添加到集合中，并且在运行时也会由于类型擦除而运行。而在数组的情况下，您将获得此类场景的运行时异常…

因此，从本质上讲，这种行为的实现是为了不向集合中添加错误的东西。现在我相信类型擦除的存在是为了与没有泛型的传统java兼容……

我认为应该添加到其他答案提到的一点是，虽然

List<Dog>不是List<Animal>在Java

这也是事实

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

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

换句话说：Java中的AList<Dog>在英语中并不意味着“狗的列表”，它的意思是“狗的列表，只有狗”。

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

回答和其他答案都是正确的。我将用一个我认为会有帮助的解决方案来添加到这些答案中。我认为这在编程中经常出现。需要注意的一件事是，对于集合（列表、集合等），主要问题是添加到集合中。这就是事情崩溃的地方。甚至删除也可以。

在大多数情况下，我们可以使用Collection<? extends T>而不是Collection<T>，这应该是首选。然而，我发现这样做并不容易的情况。关于这是否总是最好的做法，还有待讨论。我在这里展示了一个类DownCastCollection，它可以将Collection<? extends T>转换为Collection<T>（我们可以为List、Set、NavigableSet、…定义类似的类），以便在使用标准方法时使用非常不方便。下面是一个如何使用它的示例（在这种情况下我们也可以使用Collection<? extends Object>，但我保持简单来说明使用DownCastCollection。

/**Could use Collection<? extends Object> and that is the better choice.* But I am doing this to illustrate how to use DownCastCollection. **/
public static void print(Collection<Object> col){for(Object obj : col){System.out.println(obj);}}public static void main(String[] args){ArrayList<String> list = new ArrayList<>();list.addAll(Arrays.asList("a","b","c"));print(new DownCastCollection<Object>(list));}

现在类：

import java.util.AbstractCollection;import java.util.Collection;import java.util.Iterator;import java.util.NoSuchElementException;
public class DownCastCollection<E> extends AbstractCollection<E> implements Collection<E> {private Collection<? extends E> delegate;
public DownCastCollection(Collection<? extends E> delegate) {super();this.delegate = delegate;}
@Overridepublic int size() {return delegate ==null ? 0 : delegate.size();}
@Overridepublic boolean isEmpty() {return delegate==null || delegate.isEmpty();}
@Overridepublic boolean contains(Object o) {if(isEmpty()) return false;return delegate.contains(o);}private class MyIterator implements Iterator<E>{Iterator<? extends E> delegateIterator;
protected MyIterator() {super();this.delegateIterator = delegate == null ? null :delegate.iterator();}
@Overridepublic boolean hasNext() {return delegateIterator != null && delegateIterator.hasNext();}
@Overridepublic  E next() {if(!hasNext()) throw new NoSuchElementException("The iterator is empty");return delegateIterator.next();}
@Overridepublic void remove() {delegateIterator.remove();
}
}@Overridepublic Iterator<E> iterator() {return new MyIterator();}


@Overridepublic boolean add(E e) {throw new UnsupportedOperationException();}
@Overridepublic boolean remove(Object o) {if(delegate == null) return false;return delegate.remove(o);}
@Overridepublic boolean containsAll(Collection<?> c) {if(delegate==null) return false;return delegate.containsAll(c);}
@Overridepublic boolean addAll(Collection<? extends E> c) {throw new UnsupportedOperationException();}
@Overridepublic boolean removeAll(Collection<?> c) {if(delegate == null) return false;return delegate.removeAll(c);}
@Overridepublic boolean retainAll(Collection<?> c) {if(delegate == null) return false;return delegate.retainAll(c);}
@Overridepublic void clear() {if(delegate == null) return;delegate.clear();
}

}

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

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

听起来不错，不是吗？但是你只能通过Consumer和Supplier来获得Animal。如果你有一个Mammal的消费者，但一个Duck的供应商，他们不应该适合，尽管两者都是动物。为了不允许这一点，增加了额外的限制。

与上述不同，我们必须定义我们使用的类型之间的关系。

例如：

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

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

奥托，我们也可以

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

我们走另一条路：我们定义Supplier的类型并限制它可以放入Consumer。

我们甚至可以做

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

其中，具有直观的关系Life->Animal->Mammal->Dog，Cat等，我们甚至可以将Mammal放入Life消费者，但不能将String放入Life消费者。

如果您确定列表项是给定超类型的子类，您可以使用这种方法强制转换列表：

(List<Animal>) (List<?>) dogs

当您想在构造函数内部传递列表或迭代它时，这很有用。

让我们以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 calldrawAll(circleList);

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

所以Java“建筑师”有两个选择来解决这个问题：

1. 不要认为一个子类型隐含地是它的超类型，并给出一个编译错误，就像现在发生的那样

2. 考虑子类型是它的超类型，并在编译“add”方法时进行限制（因此在DradAll方法中，如果将传递圆形列表，形状的子类型，编译器应该检测到并限制您使用编译错误来执行此操作）。

出于显而易见的原因，他选择了第一种方式。

要理解这个问题，与数组进行比较很有用。

List<Dog>是List<Animal>的没有子类。
但是Dog[]是Animal[]的子类。

数组是可实现和协变的.
可实现表示它们的类型信息在运行时完全可用。
因此数组提供运行时类型安全，但不提供编译时类型安全。

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

泛型反之亦然：

因此泛型不能提供运行时类型安全，但它们提供编译时类型安全。
在下面的代码中，如果泛型是协变的，则可以在第3行制作堆污染。

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