<? super E>和<? extends E>之间的区别是什么？
例如，当您查看类java.util.concurrent.LinkedBlockingQueue时，构造函数有以下签名：
public LinkedBlockingQueue(Collection<? extends E> c)
以及该方法的一个：
public int drainTo(Collection<? super E> c)
答案 0 :(得分：169)
第一个说它是“某种类型，它是E的祖先”;第二个说它是“某种类型，它是E的子类”。 （在这两种情况下，E本身都没问题。）
因此构造函数使用? extends E形式，因此它保证当从集合中提取值时，它们都将是E或某些子类（即它是兼容的）。 drainTo方法正在尝试将值放入集合中，因此集合必须具有E 或超类的元素类型。 / p>
例如，假设您有一个类层次结构：
Parent extends Object
Child extends Parent
和LinkedBlockingQueue<Parent>。您可以在List<Child>中构建此传递，它将安全地复制所有元素，因为每个Child都是父元素。您无法传递List<Object>，因为某些元素可能与Parent不兼容。
同样，您可以将该队列排入List<Object>，因为每个Parent都是Object ...但您无法将其排入List<Child>，因为{ {1}}期望其所有元素与List<Child>兼容。
答案 1 :(得分：116)
其原因基于Java如何实现泛型。
数组示例
使用数组，您可以执行此操作（数组是协变的）
Integer[] myInts = {1,2,3,4};
Number[] myNumber = myInts;
但是，如果你试图这样做会发生什么？
myNumber[0] = 3.14; //attempt of heap pollution
这最后一行编译得很好，但是如果你运行这段代码，你可以获得ArrayStoreException。因为您试图将double放入整数数组（无论是通过数字引用访问）。
这意味着你可以欺骗编译器，但你不能欺骗运行时类型系统。这是因为数组就是我们所说的可再生类型。这意味着在运行时Java知道这个数组实际上是实例化为一个整数数组，它恰好通过Number[]类型的引用访问。
因此，正如您所看到的，有一件事是对象的实际类型，另一件事是您用来访问它的引用类型，对吧？
Java泛型问题
现在，Java泛型类型的问题是编译器丢弃了类型信息，并且在运行时它不可用。此过程称为type erasure。有很好的理由在Java中实现这样的泛型，但这是一个很长的故事，它与二进制兼容现有的代码有关。
但重要的是，由于在运行时没有类型信息，因此无法确保我们不会造成堆污染。
例如，
List<Integer> myInts = new ArrayList<Integer>();
myInts.add(1);
myInts.add(2);
List<Number> myNums = myInts; //compiler error
myNums.add(3.14); //heap pollution
如果Java编译器没有阻止你这样做，那么运行时类型系统也无法阻止你，因为在运行时没有办法确定这个列表应该只是一个整数列表。 Java运行时允许你将任何你想要的东西放入这个列表，当它只包含整数时，因为它在创建时被声明为整数列表。
因此，Java的设计者确保你不能欺骗编译器。如果你不能欺骗编译器（我们可以用数组做），你也不能欺骗运行时类型系统。
因此，我们说泛型类型不可恢复。
显然，这会妨碍多态性。请考虑以下示例：
static long sum(Number[] numbers) {
long summation = 0;
for(Number number : numbers) {
summation += number.longValue();
}
return summation;
}
现在你可以像这样使用它：
Integer[] myInts = {1,2,3,4,5};
Long[] myLongs = {1L, 2L, 3L, 4L, 5L};
Double[] myDoubles = {1.0, 2.0, 3.0, 4.0, 5.0};
System.out.println(sum(myInts));
System.out.println(sum(myLongs));
System.out.println(sum(myDoubles));
但是，如果您尝试使用泛型集合实现相同的代码，则不会成功：
static long sum(List<Number> numbers) {
long summation = 0;
for(Number number : numbers) {
summation += number.longValue();
}
return summation;
}
如果您尝试...
，您将获得编译器错误List<Integer> myInts = asList(1,2,3,4,5);
List<Long> myLongs = asList(1L, 2L, 3L, 4L, 5L);
List<Double> myDoubles = asList(1.0, 2.0, 3.0, 4.0, 5.0);
System.out.println(sum(myInts)); //compiler error
System.out.println(sum(myLongs)); //compiler error
System.out.println(sum(myDoubles)); //compiler error
解决方案是学习使用Java泛型的两个强大功能，称为协方差和逆变。
<强>协方差
使用协方差，您可以从结构中读取项目，但不能在其中写入任何内容。所有这些都是有效的声明。
List<? extends Number> myNums = new ArrayList<Integer>();
List<? extends Number> myNums = new ArrayList<Float>();
List<? extends Number> myNums = new ArrayList<Double>();
您可以阅读myNums：
Number n = myNums.get(0);
因为您可以确定无论实际列表包含什么，它都可以被上传到一个数字（毕竟任何扩展Number的数字都是数字，对吗？）
但是，不允许将任何内容放入协变结构中。
myNumst.add(45L); //compiler error
这是不允许的，因为Java无法保证通用结构中对象的实际类型。它可以是扩展Number的任何东西，但编译器无法确定。所以你可以阅读，但不能写。
<强>逆变
有了逆转，你可以做相反的事情。你可以把东西放到一个通用的结构中，但你不能从中读出来。
List<Object> myObjs = new List<Object>();
myObjs.add("Luke");
myObjs.add("Obi-wan");
List<? super Number> myNums = myObjs;
myNums.add(10);
myNums.add(3.14);
在这种情况下，对象的实际性质是对象列表，并且通过逆变，您可以将Numbers放入其中，主要是因为所有数字都将Object作为它们的共同祖先。因此，所有Numbers都是对象，因此这是有效的。
然而，假设您将得到一个数字，您无法安全地从这个逆变结构中读取任何内容。
Number myNum = myNums.get(0); //compiler-error
如您所见，如果编译器允许您编写此行，则会在运行时获得ClassCastException。
获取/放置原则
因此，当您只打算从结构中取出通用值时使用协方差，当您只打算将通用值放入结构时使用逆变，并在打算同时使用完全通用类型时使用。[/ p >
我所拥有的最好的例子是将任何类型的数字从一个列表复制到另一个列表中。只有从源获取项目，并且只有将项目放入目标中。
public static void copy(List<? extends Number> source, List<? super Number> target) {
for(Number number : source) {
target(number);
}
}
由于协方差和逆变的力量，这适用于这样的情况：
List<Integer> myInts = asList(1,2,3,4);
List<Double> myDoubles = asList(3.14, 6.28);
List<Object> myObjs = new ArrayList<Object>();
copy(myInts, myObjs);
copy(myDoubles, myObjs);
答案 2 :(得分：50)
<? extends E>将E定义为上限：“这可以转换为E”。
<? super E>将E定义为下限：“E可以投射到此。”
答案 3 :(得分：11)
我将尝试回答这个问题。但要获得一个非常好的答案，你应该查看Joshua Bloch的书Effective Java（第2版）。他描述了助记符PECS，它代表“Producer Extends，Consumer Super”。
这个想法是，如果你的代码消耗了对象的泛型值，那么你应该使用extends。但是如果要为泛型类型生成新值，则应使用super。
例如：
public void pushAll(Iterable<? extends E> src) {
for (E e: src)
push(e);
}
并且
public void popAll(Collection<? super E> dst) {
while (!isEmpty())
dst.add(pop())
}
但实际上你应该查看这本书： http://java.sun.com/docs/books/effective/
答案 4 :(得分：9)
<? super E>表示any object including E that is parent of E
<? extends E>表示any object including E that is child of E .
答案 5 :(得分：7)
您可能 want to google for the terms 逆转（<? super E>）和协方差（<? extends E>）。我发现理解泛型时最有用的是让我理解Collection.addAll的方法签名：
public interface Collection<T> {
public boolean addAll(Collection<? extends T> c);
}
就像您希望能够String添加List<Object>一样：
List<Object> lo = ...
lo.add("Hello")
您还应该能够通过List<String>方法添加String（或addAll的任何集合）：
List<String> ls = ...
lo.addAll(ls)
但是你应该意识到List<Object>和List<String>不是等价的，后者也不是前者的子类。所需要的是协变类型参数的概念 - 即<? extends T>位。
有了这个，很容易想到你想要逆变的场景（查看Comparable界面）。
答案 6 :(得分：4)
在答案之前;请明确
示例：
List stringList = new ArrayList<String>();
stringList.add(new Integer(10)); // will be successful.
希望这会帮助您更清楚地了解通配符。
//NOTE CE - Compilation Error
// 4 - For
class A {}
class B extends A {}
public class Test {
public static void main(String args[]) {
A aObj = new A();
B bObj = new B();
//We can add object of same type (A) or its subType is legal
List<A> list_A = new ArrayList<A>();
list_A.add(aObj);
list_A.add(bObj); // A aObj = new B(); //Valid
//list_A.add(new String()); Compilation error (CE);
//can't add other type A aObj != new String();
//We can add object of same type (B) or its subType is legal
List<B> list_B = new ArrayList<B>();
//list_B.add(aObj); CE; can't add super type obj to subclass reference
//Above is wrong similar like B bObj = new A(); which is wrong
list_B.add(bObj);
//Wild card (?) must only come for the reference (left side)
//Both the below are wrong;
//List<? super A> wildCard_Wrongly_Used = new ArrayList<? super A>();
//List<? extends A> wildCard_Wrongly_Used = new ArrayList<? extends A>();
//Both <? extends A>; and <? super A> reference will accept = new ArrayList<A>
List<? super A> list_4__A_AND_SuperClass_A = new ArrayList<A>();
list_4__A_AND_SuperClass_A = new ArrayList<Object>();
//list_4_A_AND_SuperClass_A = new ArrayList<B>(); CE B is SubClass of A
//list_4_A_AND_SuperClass_A = new ArrayList<String>(); CE String is not super of A
List<? extends A> list_4__A_AND_SubClass_A = new ArrayList<A>();
list_4__A_AND_SubClass_A = new ArrayList<B>();
//list_4__A_AND_SubClass_A = new ArrayList<Object>(); CE Object is SuperClass of A
//CE; super reference, only accepts list of A or its super classes.
//List<? super A> list_4__A_AND_SuperClass_A = new ArrayList<String>();
//CE; extends reference, only accepts list of A or its sub classes.
//List<? extends A> list_4__A_AND_SubClass_A = new ArrayList<Object>();
//With super keyword we can use the same reference to add objects
//Any sub class object can be assigned to super class reference (A)
list_4__A_AND_SuperClass_A.add(aObj);
list_4__A_AND_SuperClass_A.add(bObj); // A aObj = new B();
//list_4__A_AND_SuperClass_A.add(new Object()); // A aObj != new Object();
//list_4__A_AND_SuperClass_A.add(new String()); CE can't add other type
//We can't put anything into "? extends" structure.
//list_4__A_AND_SubClass_A.add(aObj); compilation error
//list_4__A_AND_SubClass_A.add(bObj); compilation error
//list_4__A_AND_SubClass_A.add(""); compilation error
//The Reason is below
//List<Apple> apples = new ArrayList<Apple>();
//List<? extends Fruit> fruits = apples;
//fruits.add(new Strawberry()); THIS IS WORNG :)
//Use the ? extends wildcard if you need to retrieve object from a data structure.
//Use the ? super wildcard if you need to put objects in a data structure.
//If you need to do both things, don't use any wildcard.
//Another Solution
//We need a strong reference(without wild card) to add objects
list_A = (ArrayList<A>) list_4__A_AND_SubClass_A;
list_A.add(aObj);
list_A.add(bObj);
list_B = (List<B>) list_4__A_AND_SubClass_A;
//list_B.add(aObj); compilation error
list_B.add(bObj);
private Map<Class<? extends Animal>, List<? extends Animal>> animalListMap;
public void registerAnimal(Class<? extends Animal> animalClass, Animal animalObject) {
if (animalListMap.containsKey(animalClass)) {
//Append to the existing List
/* The ? extends Animal is a wildcard bounded by the Animal class. So animalListMap.get(animalObject);
could return a List<Donkey>, List<Mouse>, List<Pikachu>, assuming Donkey, Mouse, and Pikachu were all sub classes of Animal.
However, with the wildcard, you are telling the compiler that you don't care what the actual type is as long as it is a sub type of Animal.
*/
//List<? extends Animal> animalList = animalListMap.get(animalObject);
//animalList.add(animalObject); //Compilation Error because of List<? extends Animal>
List<Animal> animalList = animalListMap.get(animalObject);
animalList.add(animalObject);
}
}
}
}
答案 7 :(得分：3)
带有上限的通配符看起来像“？extends Type”，代表所有类型的族，它们是Type的子类型，包含Type类型。 Type被称为上限。
具有下限的通配符看起来像“？super Type”，并且代表类型的超类型的所有类型的族，包括类型Type。类型称为下限。
答案 8 :(得分：0)
您有一个Parent类和一个从Parent类继承的Child类.Parent类是从另一个名为GrandParent Class的类继承的，因此继承的顺序是GrandParent> Parent> Child。 现在， <？扩展Parent>-接受父类或子类 <？超级父类>-接受父类或GrandParent类