有什么区别？ super E>和<？ 扩展E>？
有什么区别<? super E> <? super E>和<? extends E> <? extends E> ？
例如，当你看一下类java.util.concurrent.LinkedBlockingQueue ，这个构造函数有下面的签名：
public LinkedBlockingQueue(Collection<? extends E> c)
和一个为方法：
public int drainTo(Collection<? super E> c)
第一个说这是“某种types是E的祖先”; 第二个说这是“某种types是E的一个子类”。 （在这两种情况下，E本身都可以。）
所以构造函数使用? extends E ? extends Eforms，所以它保证，当它从集合中获取值时，它们将全部是E或某个子类（即它是兼容的）。 drainTo方法试图将值放入集合中，所以集合必须具有E 或超类的元素types。
举一个例子，假设你有一个这样的类层次结构：
Parent extends Object Child extends Parent
和LinkedBlockingQueue<Parent> 。 你可以在List<Child>构造这个传递，它将安全地复制所有的元素，因为每个Child都是父类。 您无法传入List<Object>因为某些元素可能与Parent不兼容。
同样，可以将该队列排入List<Object>因为每个Parent都是一个Object …但是由于List<Child>期望它的所有元素都与Child兼容，所以不能将其排入List<Child> 。
原因是基于Java如何实现generics。
一个数组的例子
数组可以做到这一点（数组是协变的）
Integer[] myInts = {1,2,3,4}; Number[] myNumber = myInts;
但是，如果你尝试这样做会发生什么？
myNumber[0] = 3.14; //attempt of heap pollution
这最后一行会编译得很好，但如果你运行这个代码，你可能会得到一个ArrayStoreException 。 因为你正试图把一个double放入一个整数数组（不pipe是通过数字引用来访问）。
这意味着你可以欺骗编译器，但是你不能欺骗运行时types系统。 这是因为数组就是我们所说的可调整types 。 这意味着在运行时，Java知道这个数组实际上被实例化为一个整数数组，而这个数组恰恰是通过Number[]types的引用来访问的。
所以，正如你所看到的，一件事是对象的实际types，另一件事是你用来访问它的引用types，对吧？
Javagenerics的问题
现在，Java通用types的问题是编译器会丢弃types信息，并且在运行时不可用。 这个过程被称为types擦除 。 在Java中实现类似这样的generics是有很好的理由的，但是这是一个很长的故事，并且它与二进制兼容性与已有的代码有关。
但重要的一点是，因为在运行时没有types信息，所以没有办法确保我们没有堆积污染。
例如，
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编译器不能阻止你这样做，那么运行时types系统也不能阻止你，因为在运行时没有办法确定这个列表应该只是一个整数列表。 Java运行时可以让你把任何你想要的东西放到这个列表中，当它只包含整数时，因为当它被创build时，它被声明为一个整数列表。
因此，Java的devise者确保你不能愚弄编译器。 如果你不能愚弄编译器（就像我们可以用数组做的那样），你也不能欺骗运行时types系统。
因此，我们说generics是不可确定的 。
显然，这会妨碍多态性。 考虑下面的例子：
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));
但是如果你试图用generics集合实现相同的代码，你将不会成功：
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
解决scheme是学习使用称为协变和逆变的Javagenerics的两个强大function。
协方差
通过协方差可以读取结构中的项目，但不能写入任何内容。 所有这些都是有效的声明。
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);
因为你可以确定，无论实际列表包含什么，它可以被上传到一个数字（毕竟任何扩展数字是一个数字，对不对？）
但是，你不能把任何东西放进一个协变的结构中。
myNumst.add(45L); //compiler error
这是不允许的，因为Java不能保证通用结构中对象的实际types是什么。 它可以是扩展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);
在这种情况下，对象的实际性质是一个对象列表，通过反变换，可以将数字放入其中，基本上是因为所有数字都有Object作为其共同的祖先。 因此，所有的数字都是对象，因此这是有效的。
然而，假设你会得到一个数字，你不能从这个逆变结构中安全地读取任何东西。
Number myNum = myNums.get(0); //compiler-error
正如你所看到的，如果编译器允许你写这一行，你将在运行时得到一个ClassCastException。
获取/放置原则
因此，如果只打算从结构中取出通用值，则使用协方差;如果仅打算将通用值放入结构中，并在打算使用两者时使用确切的通用types，则使用协变。
我最好的例子是下面的任何一种数字从一个列表复制到另一个列表。 它只从源头获得物品，而只是把物品放在命运之中。
public static void copy(List<? extends Number> source, List<? super Number> destiny) { for(Number number : source) { destiny.add(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);
<? extends E> <? extends E>将E定义为上限：“这可以转换为E ”。
<? super E> <? super E>将E定义为下限：“ E可以投射到这个”。
我会试着回答这个问题 但要得到一个非常好的答案，你应该检查Joshua Bloch的书Effective Java（2nd Edition）。 他描述了助记符PECS，代表“生产者延伸，消费者超级”。
这个想法是，如果你的代码是从对象中消费的通用值，那么你应该使用扩展。 但是如果你正在为generics创build新的值，你应该使用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/
您可能需要谷歌的术语 逆变 （ <? super E> ）和协方差 （ <? extends E> ）。 我发现理解generics最有用的东西是为了理解Collection.addAll的方法签名：
public interface Collection<T> { public boolean addAll(Collection<? extends T> c); }
正如你想要能够添加一个String到一个List<Object> ：
List<Object> lo = ... lo.add("Hello")
你也应该可以通过addAll方法添加一个List<String> （或任何String的集合）：
List<String> ls = ... lo.addAll(ls)
但是，您应该认识到， List<Object>和List<String>是不等价的，后者也不是前者的子类。 所需要的是协变types参数的概念 – 即<? extends T> <? extends T>位。
一旦你有了这个，想想你想要反转的情景也很简单（检查Comparable接口）。
<? super E> <? super E>表示any object including E that is parent of E
<? extends E> <? extends E>表示any object including E that is child of E .
带有上限的通配符看起来像“？extends Type”，表示Type的子types的所有types的族，包括Typetypes。 types被称为上限。
带下界的通配符看起来像“？super Type”，代表所有types为Type的超types族，Typetypes被包含在内。 types被称为下界。
在答案之前; 请说清楚
- generics仅编译时间特征以确保TYPE_SAFETY，在RUNTIME期间它不可用。
- 只有generics才会强制types安全; 如果引用没有用generics声明，那么它将工作，没有types安全。
例：
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); } } } }
