泛型是在Java 1.5中被加入了，这里不讨论泛型的细节问题，这个在Thinking in Java第四版中讲的非常清楚，这里要讲的是super和extends关键字，以及在使用这两个关键字的时候为什么会不同的限制。
首先，我们定义两个类，A和B，并且假设B继承自A。
package com.wms.test;
import java.util.ArrayList;
import java.util.List;
public class Generic {
public static void main(String[] args){
List<? extends A> list1 = new ArrayList<A>();
// list1.add(new A()); //错误，编译器无法确定List所持有的类型，所以无法安全的向其中添加对象
A a = list1.get(0);
List<? extends A> list2 = new ArrayList<B>();
List<? super B> list3 = new ArrayList<B>();
list3.add(new B());
//想要正确，必须向下转型，但是向下转型是不安全的，非常容易出错
// B b = list3.get(0); //编译器无法确定get返回的对象类型是B,还是B的父类或 Object.
List<? super B> list4 = new ArrayList<A>();
}
}
class A{}
class B extends A{}
从上面这段创建List的代码我们就更加容易理解super和extends关键字的含义了。首先要说明的一点是，Java强制在创建对象的时候必须给类型参数制定具体的类型，不能使用通配符，也就是说new ArrayList<? extends A>()，new ArrayList<?>()这种形式的初始化语句是不允许的。
从上面main函数的第一行和第二行，我们可以理解extends的含义，在创建ArrayList的时候，我们可以指定A或者B作为具体的类型。也就是，如果<? extends X>，那么在创建实例的时候，我们就可以用X或者扩展自X的类为泛型参数来作为具体的类型，也可以理解为给"?"号指定具体类型，这就是extends 的含义。
同样的，第三行和第四行就说明，如果<? super X>，那么在创建实例的时候，我们可以指定X或者X的任何的超类来作为泛型参数的具体类型。
当我们使用List<? extends X>这种形式的时候，调用List的add方法会导致编译失败，因为我们在创建具体实例的时候，可能是使用了X也可能使用了X的子类，而这个信息编译器是没有办法知道的，同时，对于ArrayList<T>来说，只能放一种类型的对象。这就是问题的本质。而对于get方法来说，由于我们是通过X或者X的子类来创建实例的，而用超类来引用子类在Java中是合法的，所以，通过get方法能够拿到一个X类型的引用，当然这个引用可以指向X也可以指向X的任何子类。
而当我们使用List<? super X>这种形式的时候，调用List的get方法会失败。因为我们在创建实例的时候，可能用了X也可能是X的某一个超类，那么当调用get的时候，编译器是无法准确知晓的。而调用add方法正好相反，由于我们使用X或者X的超类来创建的实例，那么向这个List中加入X或者X的子类肯定是没有问题的， 因为超类的引用是可以指向子类的。
最后还有一点，这两个关键字的出现都是因为Java中的泛型没有协变特性的导致的。
小结（此处还是没太明白，有待解决）
extends 可用于的返回类型限定，不能用于参数类型限定。
super 可用于参数类型限定，不能用于返回类型限定。
>带有super超类型限定的通配符可以向泛型对象中写入，带有extends子类型限定的通配符可以向泛型对象读取。
什么是PECS？
PECS指“Producer Extends，Consumer Super”。换句话说，如果参数化类型表示一个生产者，就使用<? extends T>；如果它表示一个消费者，就使用<? super T>，可能你还不明白，不过没关系，接着往下看好了。
下面是一个简单的Stack的API接口：
public interface Stack<E>{
public Stack();
public void push(E e):
public E pop();
public boolean isEmpty();
}
假设想增加一个方法，按顺序将一系列元素全部放入Stack中，你可能想到的实现方式如下：public void pushAll(Iterable<E> iter) {
for(E e : iter)
push(e);
}
假设有个Stack<Number>，想要灵活的处理Integer，Long等Number的子类型的集合
Stack<Number> stack = new Stack<Number>(); Iterable<Integer> iter = null; /* * 此时代码编译无法通过，因为对于类型Number和Integer来说，虽然后者是Number的子类， * 但是对于任意Number集合（如List<Number>）不是Integer集合（如List<Integer>）的超类， * 因为泛型是不可变的。 */ stack.pushAll(iter); //错误
此时代码编译无法通过，因为对于类型Number和Integer来说，虽然后者是Number的子类，但是对于任意Number集合（如List<Number>）不是Integer集合（如List<Integer>）的超类，因为泛型是不可变的。
幸好java提供了一种叫有限通配符的参数化类型，pushAll参数替换为“E的某个子类型的Iterable接口”：
public void pushAll01(Iterable<? extends E> iter) {
for(E e : iter)
push(e);
}
此时再这样调用：
/* * 这样就可以正确编译了，这里的<? extends E>就是所谓的 producer-extends。 * 这里的Iterable就是生产者，要使用<? extends E>。 * 因为Iterable<? extends E>可以容纳任何E的子类。在执行操作时，可迭代对象的每个元素都可以当作是E来操作。 */ stack.pushAll01(iter); //正确
这样就可以正确编译了，这里的<? extends E>就是所谓的 producer-extends。这里的Iterable就是生产者，要使用<? extends E>。因为Iterable<? extends E>可以容纳任何E的子类。在执行操作时，可迭代对象的每个元素都可以当作是E来操作。
与之对应的是：假设有一个方法popAll()方法，从Stack集合中弹出每个元素，添加到指定集合中去。
public void popAll(Collection<E> c) {
c.add(pop());
}
假设有一个Stack<Number>和Collection<Object>对象：
Stack<Number> stack = new Stack<Number>(); Collection<Object> c = null; /* * 该方法要正确，必须c为Collection<Number>，和上面同理 */ stack.popAll(c); //错误
同样上面这段代码也无法通过，解决的办法就是使用Collection<? super E>。这里的objects是消费者，因为是添加元素到objects集合中去。使用Collection<? super E>后，无论objects是什么类型的集合，满足一点的是他是E的超类，所以不管这个参数化类型具体是什么类型都能将E装进objects集合中去。
public void popAll01(Collection<? super E> c) {
c.add(pop());
}
/* * 同样上面这段代码也无法通过，解决的办法就是使用Collection<? super E>。 * 这里的objects是消费者，因为是添加元素到objects集合中去。 * 使用Collection<? super E>后，无论objects是什么类型的集合， * 满足一点的是他是E的超类，所以不管这个参数化类型具体是什么类型都能将E装进objects集合中去。 */ stack.popAll01(c);
综合代码：
package com.wms.test;
import java.util.Collection;
public class Generic {
public static void main(String[] args) {
Stack<Number> stack = new Stack<Number>();
Iterable<Integer> iter = null;
/*
* 此时代码编译无法通过，因为对于类型Number和Integer来说，虽然后者是Number的子类，
* 但是对于任意Number集合（如List<Number>）不是Integer集合（如List<Integer>）的超类，
* 因为泛型是不可变的。
*/
stack.pushAll(iter); //错误
/*
* 这样就可以正确编译了，这里的<? extends E>就是所谓的 producer-extends。
* 这里的Iterable就是生产者，要使用<? extends E>。
* 因为Iterable<? extends E>可以容纳任何E的子类。在执行操作时，可迭代对象的每个元素都可以当作是E来操作。
*/
stack.pushAll01(iter); //正确
Collection<Object> c = null;
/*
* 该方法要正确，必须c为Collection<Number>，和上面同理
*/
stack.popAll(c); //错误
/*
* 同样上面这段代码也无法通过，解决的办法就是使用Collection<? super E>。
* 这里的objects是消费者，因为是添加元素到objects集合中去。
* 使用Collection<? super E>后，无论objects是什么类型的集合，
* 满足一点的是他是E的超类，所以不管这个参数化类型具体是什么类型都能将E装进objects集合中去。
*/
stack.popAll01(c);
}
}
class Stack<E> {
public Stack(){
}
public void push(E e) {
}
public void pushAll(Iterable<E> iter) {
for(E e : iter)
push(e);
}
public void pushAll01(Iterable<? extends E> iter) {
for(E e : iter)
push(e);
}
public E pop() {
return null;
}
public void popAll(Collection<E> c) {
c.add(pop());
}
public void popAll01(Collection<? super E> c) {
c.add(pop());
}
}