泛型类（generic class）是带有一个或者多个类型形参（type parameter）的类。
泛型方法是带有类型形参的方法。
可以要求类型形参必须是一个或多个类型的子类型。
泛型类不是协变的（invariant）：当S是T的子类型时，G<S>和G<T>没有任何关系。
通过使用通配类型形参（wildcards）G<? extends T>或者G<? super T>，使得一个方法可以接受使用T的子类或者超类实例化（instantiation）的泛型类型。
泛型类和泛型方法在编译时，其类型形参将被擦除（erase）。
由于擦除（erasure）机制的存在，泛型的使用有很多限制（restriction）
Class<T>是一个泛型类，这相当有用，因为newInstance方法可以返回T。
即便泛型类和方法在虚拟机中运行时已被擦除过了，你仍然可以知道它们是如何声明的。

泛型类

如ArrayList<T>是一个泛型类（generic class），T被称为类型形参（type parameter）。泛型类如下定义：

public class Entry<K, V> {
    private K key;
    private V value;

    public Entry(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public K getKey() { return key; }
    public V getValue() { return value; }
}

泛型方法

定义如下：

public class Arrays {
    public static <T> void swap(T[] array, int i, int j) {
        T temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

类型限定（bound）

如下，类型形参T必须要实现Comparable和Serializable接口：

class Interval<T extends Comparable & Serializable> implements Serializable {

}

类型变化（variance）和通配（wildcards）

假设需要实现一个方法，用于处理Employee的子对象数组。只需要如下声明方法即可：

public static void process(Employee[] staff) { … }

例如，Manager是Employee的子类型，你只需要传递一个Manager[]给该方法即可。这种行为称之为协变（covariance），也就是说数组与其元素一同变化。

现在假设你要处理一个ArrayList，问题就出现了：ArrayList<Manager>并不是ArrayList<Employee>的子类型。
Java语言施加这种限制是有道理的，如果可以将ArrayList<Manager>对象赋值给ArrayList<Employee>类型的变量，那么会造成如下的问题：

ArrayList<Manager> bosses = new ArrayList<>();
ArrayList<Employee> empls = bosses; // Not legal, but suppose it is…
empls.add(new Employee(…)); // A nonmanager in bosses!

Java里面使用了wildcards来指定这种允许变化的方法形参和返回值。

子类通配

如下：

public static void printNames(ArrayList<? extends Employee> staff) {
    for (int i = 0; i < staff.size(); i++) {
        Employee e = staff.get(i);
        System.out.println(e.getName());
    }
}

父类通配

? super Employee这种wildcards通常被用于函数型对象。
如：

public static void printAll(Employee[] staff, Predicate<? super Employee> filter) {
    for (Employee e : staff)
        if (filter.test(e))
            System.out.println(e.getName());
}

仔细观察方法调用filter.test(e)。既然test方法可以处理Employee的父类型，那么将Employee类型的对象传递给它是安全的。这种情形是很普遍的。函数型对象天然就与其形参类型逆变（contravariant）。当一个函数能够处理employee对象时，那么提供一个能处理任意类型对象的函数当然是没问题的。

一般的，当你需要指定一个泛型的函数式接口作为方法的形参时，你应该使用super wildcard。

一些程序员喜欢用”PECS”（producer extends，consumer super）来帮助记忆何时使用extends，何时使用super。例如，一个从中读取数据的ArrayList是producer，而Predicate用于判断你提供的数据，那么就是consumer。

使用类型变量的通配

考虑Collections.sort方法的定义：

public static <T extends Comparable<? super T>> void sort(List<T> list)

类型形参T指定了Comparable接口的compareTo方法的实参类型。那么为什么不直接定义成下面这样：

public static <T extends Comparable<T>> void sort(List<T> list)

这样的话太过限制。假设Employee类实现了Comparable，然后Manager类继承Employee。这样Manager类实现了Comparable，而没有实现Comparable，那么Manager就不是Comparable的子类，但是它是Comparable

未作限制的通配

如下：

public static boolean hasNulls(ArrayList<?> elements) {
    for (Object e : elements) {
        if (e == null) return true;
    }
    return false;
}

当然，上面的方法完全可以使用一个泛型方法来替代：

public static <T> boolean hasNulls(ArrayList<T> elements)

但是通配类型的方式更加容易理解。

通配捕获

通配类型（?）可以用作类型实参，但是不能用于声明变量，如下：

public static void swap(ArrayList<?> elements, int i, int j) {
    ? temp = elements.get(i); // Won’t work
    elements.set(i, elements.get(j));
    elements.set(j, temp);
}

这样的情况可以使用一个辅助方法来捕获这个通配类型，如下：

public static void swap(ArrayList<?> elements, int i, int j) {
    swapHelper(elements, i, j);
}

private static <T> void swapHelper(ArrayList<T> elements, int i, int j) {
    T temp = elements.get(i);
    elements.set(i, elements.get(j));
    elements.set(j, temp);
}

JVM中的泛型

泛型对于虚拟机是不可见的，仅仅作用于编译阶段。编译后，类型变量被替换。没有限定的类型变量替换为Object，有限定的情况下被替换为第一个限定类型。
因此在编译泛型代码的时候，编译器会插入强制类型转换或者桥方法。

插入类型转换

Entry<String, Integer> entry = …;
String key = entry.getKey();

上面的getKey方法在经过擦除后返回是Object，因而编译器会生成类似如下的代码：

String key = (String) entry.getKey();

桥方法（bridge method）

当编译器在擦除方法的形参和返回类型时，有时需要合成bridge method。如下：

public class WordList extends ArrayList<String> {
    public void add(String e) {
        return isBadWord(e) ? false : super.add(e);
    }
    …
}

再考虑下面的代码片段：

WordList words = …;
ArrayList<String> strings = words; // OK—conversion to superclass
strings.add("C++");

调用ArrayList的add方法时，由于多态机制的存在，最终调用的方法是WordList类的add方法。然而多态能够正常工作，依赖于编译器合成的bridge method。因为ArrayList在经过擦除后，其add方法接受的参数是一个Object，因此WordList类的add方法并没有真正Override，所以多态机制是不能工作的。除非编译器在WordList类中生成一个桥方法如下：

public void add(Object e) {
    add((String) e);
}

当方法的返回类型变化时，桥方法依然有效，如下：

public class WordList extends ArrayList<String> {
    public String get(int i) {
        return super.get(i).toLowerCase();
    }
    …
}

此时WordList类中有两个get方法，其中第二个是编译器合成的：

String get(int) // Defined in WordList
Object get(int) // Overrides the method defined in ArrayList

泛型的一些限制

由于类型擦除机制的存在，在使用泛型类和方法时存在一些限制。
1. 泛型类不能使用基本类型的实参进行初始化
2. 在运行时，所有的类型都是原始类型
3. 不能实例化类型变量
4. 不能构造一个泛型类型的数组
5. 不能在static上下文中使用类型变量（因为静态域一个类中只有一份）
6. 不能定义擦除后会造成冲突的方法
7. 不能抛出泛型类对象的异常，也不能使用类型变量来捕获异常

反射和泛型

Class类

虚拟机中的泛型信息

对于Collections类的方法static <T extends Comparable<? super T>> void sort(List<T> list)来说，可以这样通过反射得知整个方法签名。

Method m = Collections.class.getMethod("sort", List.class);
TypeVariable<Method>[] vars = m.getTypeParameters();
String name = vars[0].getName(); // "T"

java.lang.reflect包中的Type接口用于表示泛型类型声明。该接口有如下子类型：
1. Class类，用于描述具体的类型
2. TypeVariable接口，描述类型变量（如T extends Comparable<? super T>）
3. WildcardType接口，描述通配类型（如? super T）
4. ParameterizedType接口，描述泛型类或者接口类型（如Comparable<? super T>）
5. GenericArrayType接口，描述泛型数组（如T[]）
sort方法中的T类型变量有一个bound，可以这样来处理：

Type[] bounds = vars[0].getBounds();
if (bounds[0] instanceof ParameterizedType) { // Comparable<? super T>
    ParameterizedType p = (ParameterizedType) bounds[0];
    Type[] typeArguments = p.getActualTypeArguments();
    if (typeArguments[0] instanceof WildcardType) { // ? super T
        WildcardType t = (WildCardType) typeArguments[0];
        Type[] upper = t.getUpperBounds(); // ? extends … & …
        Type[] lower = t.getLowerBounds(); // ? super … & …
        if (lower.length > 0) {
            String description = lower[0].getTypeName(); // "T"
            …
        }
    }
}

Java核心技术之泛型

泛型类