我们前面已经讲到了泛型的继承关系：Pair<Integer>不是Pair<Number>的子类。
考察下面的set方法：
void set(Pair<Integer> p, Integer first, Integer last) { p.setFirst(first); p.setLast(last); }
传入Pair<Integer>是允许的，但是传入Pair<Number>是不允许的。
和extends通配符相反，这次，我们希望接受Pair<Integer>类型，以及Pair<Number>、Pair<Object>，因为Number和Object是Integer的父类，setFirst(Number)和setFirst(Object)实际上允许接受Integer类型。
我们使用super通配符来改写这个方法：
void set(Pair<? super Integer> p, Integer first, Integer last) { p.setFirst(first); p.setLast(last); }
注意到Pair<? super Integer>表示，方法参数接受所有泛型类型为Integer或Integer父类的Pair类型。
下面的代码可以被正常编译：
1 import java.util.*; 2 public class Demo13{ 3 4 public static void main(String[] args) throws Exception{ 5 Pair<Integer> p1 = new Pair<>(12,34); 6 Pair<Number> p2 = new Pair<>(12.23,34.65); 7 //<? super Integer>表示类型为Integer或者Integer的父类， 8 //而Integer和Number明显是符合的， 9 //自然他们的泛型类Pair<Integer>和Pair<Number>也就是符合Pair<? super Integer>的参数传入的 10 //所以下面两行调用是可以的 11 setSame(p1,10); 12 setSame(p2,20); 13 System.out.println(p1.getFirst() + "," + p1.getLast()); 14 System.out.println(p2.getFirst() + "," + p2.getLast()); 15 } 16 17 static void setSame(Pair<? super Integer> p,Integer n){ 18 p.setFirst(n); 19 p.setLast(n); 20 } 21 } 22 23 //定义一个泛型类 24 class Pair<T> { 25 private T first; 26 private T last; 27 public Pair(T first,T last){ 28 this.first = first; 29 this.last = last; 30 } 31 public T getFirst(){ 32 return first; 33 } 34 public T getLast(){ 35 return last; 36 } 37 38 public void setFirst(T first){ 39 this.first = first; 40 } 41 42 public void setLast(T last){ 43 this.last = last; 44 } 45 }
考察Pair<? super Integer>的setFirst()方法，它的方法签名实际上是：
void setFirst(? super Integer);
因此，可以安全地传入Integer类型。
再考察Pair<? super Integer>的getFirst()方法，它的方法签名实际上是：
? super Integer getFirst();
这里注意到我们无法使用Integer类型来接收getFirst()的返回值，即下面的语句将无法通过编译：
Integer x = p.getFirst();
因为如果传入的实际类型是Pair<Number>，编译器无法将Number类型转型为Integer。
注意：虽然Number是一个抽象类，我们无法直接实例化它。但是，即便Number不是抽象类，这里仍然无法通过编译。此外，传入Pair<Object>类型时，编译器也无法将Object类型转型为Integer。
唯一可以接收getFirst()方法返回值的是Object类型：
Object obj = p.getFirst();
因此，使用<? super Integer>通配符表示：
-
允许调用
set(? super Integer)方法传入Integer的引用； -
不允许调用
get()方法获得Integer的引用。
唯一例外是可以获取Object的引用：Object o = p.getFirst()。
换句话说，使用<? super Integer>通配符作为方法参数，表示方法内部代码对于参数只能写，不能读。
对比extends和super通配符
我们再回顾一下extends通配符。作为方法参数，<? extends T>类型和<? super T>类型的区别在于：
-
<? extends T>允许调用读方法T get()获取T的引用，但不允许调用写方法set(T)传入T的引用（传入null除外）； -
<? super T>允许调用写方法set(T)传入T的引用，但不允许调用读方法T get()获取T的引用（获取Object除外）。
一个是允许读不允许写，另一个是允许写不允许读。
先记住上面的结论，我们来看Java标准库的Collections类定义的copy()方法：
public class Collections { // 把src的每个元素复制到dest中: public static <T> void copy(List<? super T> dest, List<? extends T> src) { for (int i=0; i<src.size(); i++) { T t = src.get(i); dest.add(t); } } }
它的作用是把一个List的每个元素依次添加到另一个List中。它的第一个参数是List<? super T>，表示目标List，第二个参数List<? extends T>，表示要复制的List。我们可以简单地用for循环实现复制。在for循环中，我们可以看到，对于类型<? extends T>的变量src，我们可以安全地获取类型T的引用，而对于类型<? super T>的变量dest，我们可以安全地传入T的引用。
我们来使用上面的方法来编写一个Demo测试
1 import java.util.*; 2 public class Demo13{ 3 4 public static void main(String[] args) throws Exception{ 5 //初始化一个ArrayList源对象 6 List<Integer> src = new ArrayList<>(); 7 //添加元素 8 src.add(12); 9 src.add(53); 10 src.add(75); 11 //初始化一个ArrayList目标对象 12 List<Integer> dest = new ArrayList<>(); 13 //调用方法将src对象元素赋值到dest对象中 14 copy(dest,src); 15 //查看dest对象中的元素 16 for(int i=0;i<dest.size();i++){ 17 System.out.print(dest.get(i) + " "); 18 } 19 } 20 21 //将src对象元素赋值到dest对象中 22 public static <T> void copy(List<? super T> dest,List<? extends T> src){ 23 for(int i=0;i<src.size();i++){ 24 T t = src.get(i); 25 dest.add(t); 26 } 27 } 28 }
这个copy()方法的定义就完美地展示了extends和super的意图：
-
copy()方法内部不会读取dest，因为不能调用dest.get()来获取T的引用； -
copy()方法内部也不会修改src，因为不能调用src.add(T)。
这是由编译器检查来实现的。如果在方法代码中意外修改了src，或者意外读取了dest，就会导致一个编译错误：
1 public class Collections { 2 // 把src的每个元素复制到dest中: 3 public static <T> void copy(List<? super T> dest, List<? extends T> src) { 4 ... 5 T t = dest.get(0); // compile error! 6 src.add(t); // compile error! 7 } 8 }
这个copy()方法的另一个好处是可以安全地把一个List<Integer>添加到List<Number>，但是无法反过来添加：
// copy List<Integer> to List<Number> ok: List<Number> numList = ...; List<Integer> intList = ...; Collections.copy(numList, intList); // ERROR: cannot copy List<Number> to List<Integer>: Collections.copy(intList, numList);
而这些都是通过super和extends通配符，并由编译器强制检查来实现的。
PECS原则
何时使用extends，何时使用super？为了便于记忆，我们可以用PECS原则：Producer Extends Consumer Super。
即：如果需要返回T，它是生产者（Producer），要使用extends通配符；如果需要写入T，它是消费者（Consumer），要使用super通配符。
还是以Collections的copy()方法为例：
public class Collections { public static <T> void copy(List<? super T> dest, List<? extends T> src) { for (int i=0; i<src.size(); i++) { T t = src.get(i); // src是producer dest.add(t); // dest是consumer } } }
需要返回T的src是生产者，因此声明为List<? extends T>，需要写入T的dest是消费者，因此声明为List<? super T>。
无限定通配符
我们已经讨论了<? extends T>和<? super T>作为方法参数的作用。实际上，Java的泛型还允许使用无限定通配符（Unbounded Wildcard Type），即只定义一个?：
void sample(Pair<?> p) { }
因为<?>通配符既没有extends，也没有super，因此：
- 不允许调用
set(T)方法并传入引用（null除外）； - 不允许调用
T get()方法并获取T引用（只能获取Object引用）。
换句话说，既不能读，也不能写，那只能做一些null判断：
static boolean isNull(Pair<?> p) { return p.getFirst() == null || p.getLast() == null; }
大多数情况下，可以引入泛型参数<T>消除<?>通配符：
static <T> boolean isNull(Pair<T> p) { return p.getFirst() == null || p.getLast() == null; }
<?>通配符有一个独特的特点，就是：Pair<?>是所有Pair<T>的超类：
1 public class Main { 2 public static void main(String[] args) { 3 Pair<Integer> p = new Pair<>(123, 456); 4 Pair<?> p2 = p; // 安全地向上转型 5 System.out.println(p2.getFirst() + ", " + p2.getLast()); 6 } 7 8 } 9 10 class Pair<T> { 11 private T first; 12 private T last; 13 14 public Pair(T first, T last) { 15 this.first = first; 16 this.last = last; 17 } 18 19 public T getFirst() { 20 return first; 21 } 22 public T getLast() { 23 return last; 24 } 25 public void setFirst(T first) { 26 this.first = first; 27 } 28 public void setLast(T last) { 29 this.last = last; 30 } 31 }
上述代码是可以正常编译运行的，因为Pair<Integer>是Pair<?>的子类，可以安全地向上转型。
小结
使用类似<? super Integer>通配符作为方法参数时表示：
-
方法内部可以调用传入
Integer引用的方法，例如：obj.setFirst(Integer n);； -
方法内部无法调用获取
Integer引用的方法（Object除外），例如：Integer n = obj.getFirst();。
即使用super通配符表示只能写不能读。
使用extends和super通配符要遵循PECS原则。
无限定通配符<?>很少使用，可以用<T>替换，同时它是所有<T>类型的超类。