使用通配符的原因：Java中的数组是协变的，但是泛型不支持协变。
数组的协变
首先了解下什么是数组的协变，看下面的例子：
Number[] nums = new Integer[10]; // OK
因为Integer是Number的子类，一个Integer对象也是一个Number对象，所以一个Integer的数组也是一个Number的数组，这就是数组的协变。
Java把数组设计成协变的，在一定程度上是有缺陷的。因为尽管把Integer[]赋值给Number[]，Integer[]可以向上转型为Number[]，但是数据元素的实际类型是Integer，只能向数组中放入Integer或者Integer的子类。如果向数组中放入Number对象或者Number其他子类的对象，对于编译器来说也是可以通过编译的。但是运行时JVM能够知道数组元素的实际类型是Integer，当其它对象加入数组是就会抛出异常（java.lang.ArrayStoreException）。
泛型的设计目的之一就是保证了类型安全，让这种运行时期的错误在编译期就能发现，所以泛型是不支持协变的。例如：
List<Number> nums = new ArrayList<Integer>(); // incompatible types
当确实需要建立这种向上转型的类型关系的时候，就需要用到泛型的通配符特性了。例如：
List<? extends Number> nums = new ArrayList<Integer>(); // OK
无边界通配符（Unbounded Wildcards）
语法：
class-name<?> var-name
例子：
public static void print(List<?> list) {
for (Object obj : list) {
System.out.println(o);
}
}
List<?> list和List list的区别：
- List<?> list是表示持有某种特定类型对象的List，但是不知道是哪种类型；List list是表示持有Object类型对象的List。
- List<?> list因为不知道持有的实际类型，所以不能add任何类型的对象，但是List list因为持有的是Object类型对象，所以可以add任何类型的对象。
注意：List<?> list可以add(null)，因为null是任何引用数据类型都具有的元素。
Pair<?> 和 Pair 的区别：
- Pair<?>的 ? getFirst()方法，返回值只能赋值给一个Object对象，它的void setFirst(? )方法不能被调用，甚至不能用Object调用。
-
为什么要使用这样脆弱的类型？它对于许多简单的操作非常有用。例如 ，下面这个方法将用来测试一个 pair 是否包含一个 mill 引用，它不需要实际的类型。 public static boolean hasNulls (Pair<?> p) { return p.getFirstO = null | | p.getSecondO = null ; } 通过将 hasNulls 转换成泛型方法,可以避免使用通配符类型： public static <T> boolean hasNulls (Pair<T> p) 但是，带有通配符的版本可读性更强。
上边界限定的通配符（Upper Bounded Wildcards）
语法：
class-name<? extends superclass> var-name
例子：
public static double sum(List<? extends Number> list) {
double s = 0.0;
for (Number num : list) {
s += num.doubleValue();
}
return s;
}
List<? extends Number> list = new ArrayList<Integer>(); // OK
List<? extends Number> list = new ArrayList<Object>(); // error
特性：
- List<? extends Number> list表示某种特定类型（Number或者Number的子类）对象的List。跟无边界通配符一样，因为无法确定持有的实际类型，所以这个List也不能add除null外的任何类型的对象。
list.add(new Integer(1)); // error
list.add(null); // OK
- 从list中获取对象是是可以的（比如get(0)），因为在这个List中，不管实际类型是什么，但肯定都能转型为Number。
Number n = list.get(0); // OK
Integer i = list.get(0); // error
- 事实上，只要是形式参数有使用类型参数的方法，在使用无边界或者上边界限定的通配符的情况下，都不能调用。比如以java.util.ArrayList为例：
public E get(int index) // 可以调用
public int indexOf(Object o) // 可以调用
public boolean add(E e) // 不能调用
下边界限定的通配符（Lower Bounded wildcards）
语法：
class-name<? super subclass> var-name
例子：
public static void writeTo(List<? super Integer> list) {
// ...
}
List<? super Number> list = new ArrayList<Number>(); // OK
List<? super Number> list = new ArrayList<Object>(); // OK
List<? super Number> list = new ArrayList<Integer>(); // error
特性：
- List<? super Integer> list表示某种特定类型（Integer或者Integer的父类）对象的List。可以确定这个List持有的对象类型肯定是Integer或者其父类，所以往list里面add一个Integer或者其子类的对象是安全的，因为Integer或者其子类的对象都可以向上转型为Integer的父类对象。但是因为无法确定实际类型，所以往list里面add一个Integer的父类对象是不安全的。
list.add(new Integer(1)); // OK
list.add(new Object()); // error
- 当从List<? super Integer> list获取具体的数据的时候，JVM在编译的时候知道实际类型可以是任何Integer的父类，所以为了安全起见，要用一个最顶层的父类对象来指向取出的数据，这样就可以避免发生强制类型转换异常了。
Object obj = list.get(0); // OK
Integer i = list.get(0); // error
PECS原则（Producer Extends Consumer Super）
从上面上边界限定的通配符和下边界限定的通配符的特性，可以知道：
- 对于上边界限定的通配符，无法向其中加入任何对象，但是可以从中正常取出对象。
- 对于下边界限定的通配符，可以存入subclass对象或者subclass的子类对象，但是取出时只能用Object类型变量指向取出的对象。
简而言之，上边界限定（extends）的通配符适合于内容的获取，而下边界限定（super）的通配符更适合于内容的存入。所以就有了一个PECS原则来很好的解释这两种通配符的使用原则。
- 当一个数据结构作为producer对外提供数据的时候，应该只能取数据而不能存数据，所以适合使用上边界限定（extends）的通配符。
- 当一个数据结构作为consumer获取并存入数据的时候，应该只能存数据而不能取数据，所以适合使用下边界限定（super）的通配符。
- 如果既需要取数据也需要存数据，就不适合使用泛型的通配符。
public static <T> void copy(List<? super T> dest, List<? extends T> src) {
for (int i = 0; i < src.size(); i++) {
dest.set(i, src.get(i));
}
}
原文地址：https://www.cnblogs.com/everest33Tong/p/11588373.html