刚刚遇到这个问题：
List<DataNode> a1 = new ArrayList<DataNode>();
List<Tree> b1 = a1; // compile error: incompatible type
DataNode 类型是 Tree 的子类型。
public class DataNode implements Tree
令我惊讶的是，这适用于数组：
DataNode[] a2 = new DataNode[0];
Tree[] b2 = a2; // this is okay
这有点奇怪。任何人都可以对此作出解释吗？
【问题讨论】：
您在第二种情况下看到的是数组协方差。这是 IMO 的一件坏事，它使数组中的分配不安全 - 尽管在编译时很好，但它们在执行时可能会失败。
在第一种情况下，假设代码确实编译了，然后是：
b1.add(new SomeOtherTree());
DataNode node = a1.get(0);
你希望发生什么？
你可以这样做：
List<DataNode> a1 = new ArrayList<DataNode>();
List<? extends Tree> b1 = a1;
...因为那样你就只能从b1 获取东西，并且它们保证与Tree 兼容。你不能准确地调用b1.add(...)，因为编译器不知道它是否安全。
查看this section of Angelika Langer's Java Generics FAQ 了解更多信息。
【讨论】：
如果您必须从List<DataNode> 转换为List<Tree>，并且您知道这样做是安全的，那么实现此目的的一种丑陋方法是进行双重转换：
List<DataNode> a1 = new ArrayList<DataNode>();
List<Tree> b1 = (List<Tree>) (List<? extends Tree>) a1;
【讨论】：
简短的解释：最初允许它用于数组是一个错误。
更长的解释：
假设这是允许的：
List<DataNode> a1 = new ArrayList<DataNode>();
List<Tree> b1 = a1; // pretend this is allowed
那么我不能继续：
b1.add(new TreeThatIsntADataNode()); // Hey, b1 is a List<Tree>, so this is fine
for (DataNode dn : a1) {
// Uh-oh! There's stuff in a1 that isn't a DataNode!!
}
现在一个理想的解决方案将允许您在使用只读的List 的变体时进行您想要的类型转换，但在使用可读写的接口（如List）时不允许它。 Java 不允许在泛型参数上使用这种差异表示法 (*)，但即使这样做，您也无法将 List<A> 转换为 List<B>，除非 A 和 B 相同。
(*) 即写类时不允许。您可以将变量声明为 List<? extends Tree> 类型，这很好。
【讨论】：
List<DataNode> 不会扩展 List<Tree>，即使 DataNode 扩展了 Tree。那是因为在您的代码之后您可以执行 b1.add(SomeTreeThatsNotADataNode)，这将是一个问题，因为那时 a1 中也会有一个不是 DataNode 的元素。
你需要使用通配符来实现这样的事情
List<DataNode> a1 = new ArrayList<DataNode>();
List<? extends Tree> b1 = a1;
b1.add(new Tree()); // compiler error, instead of runtime error
另一方面，DataNode[] 确实扩展了 Tree[]。当时这似乎是合乎逻辑的事情，但你可以这样做：
DataNode[] a2 = new DataNode[1];
Tree[] b2 = a2; // this is okay
b2[0] = new Tree(); // this will cause ArrayStoreException since b2 is actually a DataNode[] and can't store a Tree
这就是为什么当他们将泛型添加到 Collections 时，他们选择稍微不同以防止运行时错误。
【讨论】：
在设计数组时（即几乎在设计 java 时），开发人员认为方差会很有用，所以他们允许了它。然而这个决定经常被批评，因为它允许你这样做（假设NotADataNode是Tree的另一个子类）：
DataNode[] a2 = new DataNode[1];
Tree[] b2 = a2; // this is okay
b2[0] = new NotADataNode(); //compiles fine, causes runtime error
因此，当设计泛型时，就决定泛型数据结构应该只允许显式变化。 IE。你不能做List<Tree> b1 = a1;，但你可以做List<? extends Tree> b1 = a1;。
但是，如果您执行后者，尝试使用 add 或 set 方法（或任何其他将 T 作为参数的方法）将导致编译错误。这样就不可能编译上述数组问题的等价物（没有不安全的强制转换）。
【讨论】：
简短回答： 列表 a1 与列表 b2 的类型不同； 在 a1 中，您可以放置任何扩展 DataNode 的对象类型。所以它可能包含树以外的其他类型。
【讨论】：
这是来自C#的答案，但我认为这实际上并不重要，因为原因是一样的。
“特别是，与数组类型不同，构造的引用类型不表现出“协变”转换。这意味着即使 B 是派生的，类型 List 也没有转换（隐式或显式）到 List从 A。同样，不存在从 List 到 List
这样做的理由很简单：如果允许转换为 List，那么显然可以将 A 类型的值存储到列表中。但这会破坏 List 类型列表中的每个对象始终是 B 类型的值这一不变性，否则在分配到集合类时可能会发生意外失败。”
http://social.msdn.microsoft.com/forums/en-US/clr/thread/22e262ed-c3f8-40ed-baf3-2cbcc54a216e
【讨论】：
DataNode 可能是 Tree 的子类型，但 List DataNode 不是 List Tree 的子类型。
https://docs.oracle.com/javase/tutorial/extra/generics/subtype.html
【讨论】：
这是使用类型擦除实现泛型的经典问题。
假设您的第一个示例确实有效。然后，您将能够执行以下操作：
List<DataNode> a1 = new ArrayList<DataNode>();
List<Tree> b1 = a1; // suppose this works
b1.add(new Tree());
但由于b1 和a1 指的是同一个对象，这意味着a1 现在指的是包含DataNodes 和Trees 的List。如果你尝试获取最后一个元素，你会得到一个异常（不记得是哪个）。
【讨论】：
好吧，老实说：惰性泛型实现。
没有语义上的理由不允许你的第一次做作。
顺便说一句，虽然我喜欢 C++ 中的模板，但泛型以及我们这里存在的那种愚蠢的限制是我放弃 Java 的主要原因。
【讨论】：
List<T> 代表一个可以添加元素的可变类型。如果您愿意，您可以称其为糟糕的设计决策，但一旦做出该决定，通过防止向其中添加错误类型的元素来保持类型安全是非常有意义的。