我对Java泛型如何处理继承/多态性有点困惑。
假设以下层次结构-
动物（父母）
狗-猫（儿童）
所以假设我有一个doSomething方法（列出＜Animal＞动物）。根据继承和多态性的所有规则，我会假设List<Dog>是List<Animal>，List<Cat>是List<Animal>-因此任何一个都可以传递给这个方法。不是这样。如果我想实现这种行为，我必须通过说doSomething（list<？extendsAnimal>动物）来明确告诉方法接受Animal的任何子类的列表。
我知道这是Java的行为。我的问题是为什么？为什么多态性通常是隐式的，但当涉及泛型时，必须指定它？
当前回答
其他人已经很好地解释了为什么不能将后代列表转换为超类列表。
然而，许多人访问这个问题以寻求解决方案。
因此，自Java版本10以来，该问题的解决方案如下：
（注：S=超类）
List<S> supers = List.copyOf( descendants );
如果完全安全，则此函数将执行强制转换，如果强制转换不安全，则该函数将执行复制。
有关深入解释（考虑到此处其他答案提到的潜在陷阱），请参阅相关问题和我2022年的答案：https://stackoverflow.com/a/72195980/773113
其他回答
子类型对于参数化类型是不变的。即使严格来说，类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());
其他人已经很好地解释了为什么不能将后代列表转换为超类列表。
然而，许多人访问这个问题以寻求解决方案。
因此，自Java版本10以来，该问题的解决方案如下：
（注：S=超类）
List<S> supers = List.copyOf( descendants );
如果完全安全，则此函数将执行强制转换，如果强制转换不安全，则该函数将执行复制。
有关深入解释（考虑到此处其他答案提到的潜在陷阱），请参阅相关问题和我2022年的答案：https://stackoverflow.com/a/72195980/773113
这里给出的答案并不能完全说服我，所以我再举一个例子。
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());
}
其中，有了“生活”->“动物”->“哺乳动物”->“狗”、“猫”等直观关系，我们甚至可以将“哺乳动物”放入“生活”消费者，但不能将“字符串”放入“生命”消费者。
List＜Dog＞不是List＜Animal＞的原因是，例如，您可以将猫插入List＜Animate＞，但不能插入List＜Dog>。。。在可能的情况下，可以使用通配符使泛型更具可扩展性；例如，从List＜Dog＞中读取与从List＜Animal＞中读取类似，但不是写入。
《Java语言中的泛型》和《Java教程》中的“泛型”一节对为什么某些事物是多态的或不多态的或允许使用泛型进行了非常好、深入的解释。
