在准备面试题时，我遇到了下面的代码：
List<Object> list = new ArrayList();
Map<Object, ? super ArrayList> m = new HashMap<Object, ArrayList>();
m.put(1, new Object());
m.put(2, list);
上述的两个put方法会抛出编译时错误。但是，当我添加m.put(3, new ArrayList());时，它会将其添加到Map中而不会有编译时错误。
对于我来说非常清楚，我可以将new Object()作为值添加到HashMap中，因为映射声明为< ? super ArrayList>类型；这意味着我可以添加任何高于 ArrayList （即ArrayList的super）的值和ArrayList对象本身，但不能添加低于ArrayList的任何值。
这个特定的概念在Kathy Sierra和Bert Bates的SCJP 6中写得非常好，并且基于该理论和示例，我认为它应该按照我的理解执行。请问有人能帮我理解这个错误吗？
?的含义，可能存在一个常见的误解：ArrayList的超类。ArrayList的超类型。由于确切的类型是未知的，编译器不允许你将除ArrayList本身以外的任何类型的值作为映射中的值 - 编译器没有足够的信息来检查你所做的是否类型安全。Map<Object, ArrayList> m1 = new HashMap<Object, ArrayList>();
Map<Object, ? super ArrayList> m2 = m1;
// This should not be allowed, because m2 is really a HashMap<Object, ArrayList>
m2.put(1, new Object());
<? super X>的意思是X或更大；请查看我新增的示例答案。 - ThanksForAllTheFish? super ArrayList的意思是“我不确定这个类型的确切类型，但是任何需要提供此类型实例的地方，我可以安全地提供ArrayList”。实例化通配符的实际类型可能是Object、Collection、List或ArrayList，因此您可以看到new Object()不能保证是安全的，但new ArrayList()是安全的。? super ArrayList 表示未知类型，其下限为 ArrayList。例如，它可能是 Object，但也可能是 AbstractList 或 ArrayList。ArrayList 更特定，因此可以添加任何是 ArrayList 或其子类的对象。put(1, new Object()) 失败：显然，Object 不在范围内。
put(1, list) 失败：变量的类型是 List，可以持有对 LinkedList 的引用，而 LinkedList 不符合所需的范围。
<? extends ArrayList> 的意思是你不知道它的类型，但你知道从对象中获取的类型至少与ArrayList一样具体（即ArrayList或ArrayList的子类型），并且你不能添加任何东西，因为你不知道类型可能是ArrayList的哪个子类。请参见PECS。 - BohemianList<? extends T>，那么这个 List 最多是一个 List<T>，也可能是 T 的某个子类。如果你有一个 List<? super T>，那么这个 List 最少是一个 List<T>，也可能是 T 的某个超类。这个边界告诉你关于曾经存在的泛型参数的一些信息。 - Radiodef? super ArrayList并不意味着“任何高于ArrayList的值”。它的意思是“某种未知类型?的任何值，它是ArrayList的超类型”。实际上，在你的代码中可以看到这一点，因为m的值是ArrayList类型：
HashMap<Object, ArrayList> hm = new HashMap<Object, ArrayList>();
Map<Object, ? super ArrayList> m = hm;
m.put(1, new Object());
ArrayList a = hm.get(1);
这段代码明显有问题，因为 a 应该是一个 ArrayList，而不是一个 Object。
Map<Object, ? super ArrayList> m可以被许多地图引用，例如：
HashMap<Object, ArrayList>HashMap<Object, List>HashMap<Object, Object>但这些地图都有自己的目的，即精确地保存这些类型的数据：
ArrayListListObject或它们的子类型，但从不使用它们的超类型，因为超类型可能没有所有必要的成员（方法/字段），而它们的子类型具有这些成员。
考虑以下示例：
List<Banana> bananas = new ArrayList<>();//list only for bananas <------+
List<? super Banana> list = bananas;//this is fine |
// |
list.add(new Object);//error, and can thank compiler for that |
//because you just tried to add Object to this list --+
//which should contain only Bananas
list.add(new Banana());// this is FINE because whatever precise type of list
// it can accept also banana
List<Fruit> fruits = new ArrayList<>();//can contain Bananas, Apples, and so on
List<? super Banana> list = fruits;//again, this is fine
list.add(new Object)//wrong, as explained earlier
list.add(new Banana());// OK because we know that list will be of type which
// can also accept Banana
Collection<? super E> x;
Collection<? extends E> y;
x = 一种未知类型的集合，该类型是E或E的超类。
y = 一种未知类型的集合，该类型是E或E的子类。
x的用例：可以向其中添加E或任何E的子类。
y的用例：可以从中检索E或任何E的子类。
这也被称为PECS缩写：生产者扩展，消费者超级。
如果集合应该能够“消耗”E（E可以添加到其中），则将泛型声明为? super E。
如果集合应该能够“产生”E（可以从中检索E），则将泛型声明为? extends E。
希望这解释了为什么问题中的代码无法编译：只有ArrayList或其子类型才能添加到映射中。
然而，你无法将一个Object放入这样的映射中：因为Object是Java类类型的根，因此它比所有其他类型都要“小”。
这个示例可以编译（使用标准的javac）：
import java.util.*;
public class test {
public static void main(String[] args) {
ArrayList list = new ArrayList();
Map<Object, ? super List> m = new HashMap<Object, List>();
m.put(2, list);
}
}
Map<Object, ? super ArrayList> m = new HashMap<Object,
ArrayList>();
你的 "?" 变成了 ArrayList，因此你除了通过继承 ArrayList 来添加元素之外就不能再添加任何东西了。
你所说的是正确的。当你只是在运行代码时，把所有的ArrayList的超类放入Map作为一个值是有意义的。
但问题是这是设计上的问题。泛型检查仅在编译时而不是运行时进行。因此，在编译时，尽管你知道Object是ArrayList的超类；编译器不知道。所以编译器会对此发出警告。唯一可以作为值放入的是null或ArrayList对象本身。