? 和 T 是什么?
? 是通配符（wildcard，记住这个单词，这样在报错时就知道说的是 ? 通配符），T 是类型变量。
- 根据字面意思，
<? extends T>表示 任何继承自类型T的类型，<? super T>表示 任何是类型T的超类的类型。
? extend/super Xx不能用于声明处。
下面是用于表达式的正确例子：Plate<? super Fruit> p = new Plate<Fruit>(new Fruit()); Plate<? extend Fruit> p1;下面是用于声明处的错误例子：
public class Fruit {} public class Plate<? extends Fruit> {} // 报错 Unexpected wildcard
-
T则与问号不同，它只能用于声明处。<T extends Fruit>表示声明一个类型变量T，它是Fruit的一个具体子类。不能写<T super Fruit>，因为这样是没有任何意义的。原因是所有泛型在编译时都会被擦除，T所代表的是一个Fruit的超类，但是具体是哪个类却是在运行时被决定的，编译器为了类型安全，只能做最大限度的包容，因此所有的T类型都会在编译器变为Object。所以，写<T super Fruit>等同于写<Object>，因此不支持<T super Xx>。
上界和下界
下面代码就是上界通配符(Upper Bounds Wildcards)
Plate<? extends Fruit> plate;
它的表意是，一个能放 Fruit 及其子类的盘子。
下面代码就是下界通配符(Lower Bounds Wildcards)
Plate<? super Fruit> plate
它的表意是，一个能放 Fruit 及其父类的盘子。
PECS 原则
以下原则，我们都先假设有这样的类：
class Plate<T> {
private T item;
public Plate(T t) {
item = t;
}
public void set(T t) {
item = t;
}
public T get() {
return item;
}
}
1. <? extends T> 不能往里存，只能往外取（被称作协变）
- 往里存的意思就是，不能调用
<? extends T>泛型类的以T为形参的方法。 - 往外取的意思就是，可以调用
<? extends T>泛型类的以T为返回值的方法。
Plate<? extends Fruit> p = new Plate<Apple>(new Apple()); // 实例 p 是协变的
// 不能被存入任何元素
p.set(new Fruit()); // exception
p.set(new Apple()); // exception
// 取出来的东西只能放在 Fruit 或它的基类里
Fruit fruit = p.get();
Object object = p.get();
Apple apple = p.get(); // exception
注意以上代码，只有在构造函数中可以对
T类型的item进行赋值，通过set方法进行赋值是不行的。原因是编译器通过<? extends Fruit>只知道p接受的是Fruit及其子类，但是具体是哪个不能确定。但是从写法上，我们在构造时已经显式地指明了p的泛型类型是Apple，为什么编译器还不知道呢？这个涉及到类型擦除。这是因为 JVM 在设计初期就没有考虑过泛型，因此对于 JVM 编译成的字节码来说，也没有泛型的概念，JVM 会使用一个占位符 CAP#1 来表示p接受一个Fruit或子类，这里就通过 CAP#1 把类型擦除了。所以无论想往p插入任何类型都不可以（因为你不能赋值一个 CAP#1 类型）。但是你可以从p中往外取 CAP#1，因为 CAP#1 代表的是Fruit及其子类，因此往外取时，类型为Fruit及其超类就总是安全的。但是，将
<? extends Fruit>替换为一个具体的类型，set方法就是生效的。这是因为编译器已经知道p只会接受一个确定类型的水果Apple。
Plate<Apple> applePlate = new Plate<>(new Apple()); // 实例 applePlate 是不变的
applePlate.set(new Apple());
Apple apple = applePlate.get();
applePlate.set(new GreenApple());
- 但是下面的写法是不被接受的。因为泛型
T是一个类型变量，它不能被用于表达式中，只能被用于声明处。
Plate<T extends Fruit> p = new Plate<>(new Apple());
- 如果写
Plate<?>，则表示Plate中放的是任意类型，因此什么也存不进去，可以往外取Object。因为<?>隐式地表示<? extends Object>。
Plate<?> anyPlate = new Plate<>(new Apple());
Object o = anyPlate.get();
其实存不进去的根本原因是因为，Java 类没有一个共同的子类，但是却有一个共同的父类
Object。所以永远可以向上转型取数据，却不能向下转型存数据。
2. 下界 <? super Fruit> 不影响往里存，但是往外取只能放在 Object（被称作逆变）
使用下界 <? super Fruit> 的意思是，Plate 中存放的是任意 Fruit 的基类，但是不确定是哪一个。因此往里放 Fruit 以及其子类一定是可以的（因为这些类一定是 <? super Fruit> 的子类）。但是往外取时就只能是 Object，因为编译器不知道你存的是 Fruit 还是 Meat。Fruit 和 Meat 就只有一个共同父类，那就是 Object。因此往外取 Object 一定是对的。
3. PECS(Producer Extends Consumer Super)
3.1 Producer Extends 你写的类是主要作为生产者向外提供数据，那么就用 extends
3.2 Consumer Super 你写的类是主要作为消费者，需要吃进数据，那么就用 super
4. 看一个复杂点的例子
class X< T extends List<? extends Number> > {
public void someMethod(T t) {
t.add(new Long(0L)); // error
Number n = t.remove(0);
}
}
class Test {
public static void main(String[] args) {
X<ArrayList< Long >> x1 = new X<ArrayList<Long>>();
X<ArrayList< String >> x2 = new X<ArrayList<String>>(); // error
}
}
类 X 声明了一个类型参数 T。T 是一个协变类型 List<? extends Number> 的子类。因此类 X 的方法 someMethod(T t) 可以接受一个类型为 T 的参数 t，但是不能往 t 里放任何数据。因为 <? extends Number> 限制了只能往外取。
这里的协变就是使用处协变。泛型声明
T extends List<? extends Number>并没有直接限制X的类方法声明的地方对T的使用，即X的类方法依然可以接受T的入参。但是在 Kotlin 中，我们就可以通过在T前面加上关键字out来使T在声明处就产生协变。
5. 自限定类型
class SelfBounded<T extends SelfBounded<T>>
这个写法刚看起来宁人十分疑惑。声明了一个类型 T，它是 SelfBounded<T> 的子类型，这似乎是一个无限循环。其实自限定类型是为子类提供了一个模板，泛型 T 在子类中只能表示子类这个具体类，而不能是其他类型。
interface SelfBoundSetter<T extends SelfBoundSetter<T>> {
void set(T args);
}
interface Setter extends SelfBoundSetter<Setter> {}
public class SelfBoundAndCovariantArguments {
void testA(Setter s1, Setter s2, SelfBoundSetter sbs) {
s1.set(s2);
s1.set(sbs); // 编译错误
}
}
5.1 自限定类型的具体例子
如果你去看 Enum 的源码，就会发现，Enum 的声明是自限定的类型。
public abstract class Enum<E extends Enum<E>> {
...
}
一个具体的枚举类型 Color 在编译时就被翻译成了 Color extends Enum<Color>。如我们前面所说，自限定类型主要目的是为子类提供一种模板，我们来看看枚举类 Enum 是怎么用这个模板的：
public abstract class Enum< E extends Enum<E>> implements Comparable< E >, Serializable {
private final String name;
public final String name() { ... }
private final int ordinal;
public final int ordinal() { ... }
protected Enum(String name, int ordinal) { ... }
public String toString() { ... }
public final boolean equals(Object other) { ... }
public final int hashCode() { ... }
protected final Object clone() throws CloneNotSupportedException { ... }
public final int compareTo( E o) { ... }
public final Class< E > getDeclaringClass() { ... }
public static <T extends Enum<T>> T valueOf(Class<T> enumType, String name) { ... }
}
如果我们声明一个具体的媒体类型 Color：
enum Color {RED, BLUE, GREEN}
编译器会将它翻译成：
public final class Color extends Enum<Color> {
public static final Color[] values() { return (Color[])$VALUES.clone(); }
public static Color valueOf(String name) { ... }
private Color(String s, int i) { super(s, i); }
public static final Color RED;
public static final Color BLUE;
public static final Color GREEN;
private static final Color $VALUES[];
static {
RED = new Color("RED", 0);
BLUE = new Color("BLUE", 1);
GREEN = new Color("GREEN", 2);
$VALUES = (new Color[] { RED, BLUE, GREEN });
}
}
其中 Color 的 Color.compareTo 方法应该使用一个 Color 类型作为参数，自限定类型刚好就能满足这样的模板。
5.2 自限定类型的缺点
从名字上来看，自限定这个名字会让我们误以为像上面的 Color 类一样，其中的泛型方法只能接受子类自己，比如 Color.compareTo 只能接受 Color 类型的参数。其实不然，其实自限定类型还可以接受它的兄弟类。
public interface SelfBound<E extends SelfBound<E>> {}
public class SelfBound1 implements SelfBound<SelfBound1> {}
public class SelfBound2 implements SelfBound<SelfBound1> {} // 注意这里接受的泛型实参为 SelfBound1
SelfBound2 接受了它的兄弟类型 SelfBound1，而不是像 SelfBound1 一样接受的自己。如果以为 SelfBound2 的声明只能接受它自己 SelfBound2，那就完全错误了。因此自限定这个叫法有点名不符其实。
6. 捕获转换
<?> 被称作无界通配符，它有一个特殊的应用场景叫做捕获转换。
public class CaptureConversion {
static <T> void f1(Holder<T> holder) {
T t = holder.get();
System.out.println(t.getClass().getSimpleName());
}
static void f2(Holder<?> holder) {
// 做一些与 Holder 中与泛型类型无关的事，然后再调用 f1(holder)，
// 将 Holder 中的类型给捕获
f1(holder);
}
@SuppressWarnings("unchecked")
public static void main(String[] args) {
Holder raw = new Holder<Integer>(1);
f2(raw);
Holder rawBasic = new Holder();
rawBasic.set(new Object());
f2(rawBasic);
Holder<?> wildcarded = new Holder<Double>(1.0);
f2(wildcarded);
}
static class Holder<T> {
private T t;
public Holder(){}
public Holder(T t){}
public void set(T t){
this.t = t;
}
public T get() {
return t;
}
}
}
/* 程序输出
Integer
Object
Double
*/
类型捕获的地方当然可以写已声明的类型 T。但是这样会降低程序的可读性，因为在 f2() 中根本用不到泛型 T 相关的知识。而且，<?> 使 f2() 产生了协变，让方法 f2() 中只能从 holder 中取数据，而不能写数据。但是将 holder 传给方法 f1() 后，由于方法 f1() 有声明了不变的泛型 <T>，因此 holder 又被类型投影为了不变的类型。
