搞懂泛型

静态泛型方法

在 static 后加一个 <K>

public static <K> Pair<K> create(K first,K last){
        return new Pair<K>(first, last);
    }

不能在静态域或方法中引用类型变量

public class Singleton<T>{
    private static T singleInstance;//Error
    public static T getSingleInstance(){//Error
        if (singleInstance == null) {
            return singleInstance;
        }
    }
}

擦拭法

Java语言的泛型实现方式是擦拭法（Type Erasure）。

所谓擦拭法是指，虚拟机对泛型其实一无所知，所有的工作都是编译器做的。

例如，我们编写了一个泛型类Pair <T>，这是编译器看到的代码：

public class Pair<T> {
    private T first;
    private T last;
    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() {
        return first;
    }
    public T getLast() {
        return last;
    }
}

而虚拟机根本不知道泛型。这是虚拟机执行的代码：

public class Pair {
    private Object first;
    private Object last;
    public Pair(Object first, Object last) {
        this.first = first;
        this.last = last;
    }
    public Object getFirst() {
        return first;
    }
    public Object getLast() {
        return last;
    }
}

因此，Java使用擦拭法实现泛型，导致了：

• 编译器把类型<T>视为Object；
• 编译器根据<T>实现安全的强制转型。

所以，Java的泛型是由编译器在编译时实行的，编译器内部永远把所有类型 T 视为 Object 处理，但是，在需要转型的时候，编译器会根据 T 的类型自动为我们实行安全地强制转型。

了解了Java泛型的实现方式——擦拭法，我们就知道了Java泛型的局限：

局限一：<T>不能是基本类型，例如 int，因为实际类型是Object，Object类型无法持有基本类型：

Pair<int> p = new Pair<>(1, 2); // compile error!

局限二：无法取得带泛型的Class。观察以下代码：

public class Main {
    public static void main(String[] args) {
        Pair<String> p1 = new Pair<>("Hello", "world");
        Pair<Integer> p2 = new Pair<>(123, 456);
        Class c1 = p1.getClass();
        Class c2 = p2.getClass();
        System.out.println(c1==c2); // true
        System.out.println(c1==Pair.class); // true

    }
}

class Pair<T> {
    private T first;
    private T last;
    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() {
        return first;
    }
    public T getLast() {
        return last;
    }
}

因为 T 是Object，我们对Pair<String>和Pair<Integer>类型获取Class时，获取到的是同一个Class，也就是Pair类的Class。

换句话说，所有泛型实例，无论T的类型是什么，getClass() 返回同一个Class实例，因为编译后它们全部都是Pair<Object>。

局限三：无法判断带泛型的Class：

Pair<Integer> p = new Pair<>(123, 456);
// Compile error:
if (p instanceof Pair<String>.class) {
}

原因和前面一样，并不存在Pair<String>.class，而是只有唯一的Pair.class

局限四：不能实例化T类型：

public class Pair<T> {
    private T first;
    private T last;
    public Pair() {
        // Compile error:
        first = new T();
        last = new T();
    }
}

上述代码无法通过编译，因为构造方法的两行语句：

first = new T();
last = new T();

变成了

first = new Object();
last = new Object();

这样一来，创建new Pair<String>()和创建new Pair<Integer>()就全部成了Object，显然编译器要阻止这种类型不对的代码。

要实例化 T 类型，我们必须借助额外的Class<T>参数：

public class Pair<T> {
    private T first;
    private T last;
    public Pair(Class<T> clazz) {
        first = clazz.newInstance();
        last = clazz.newInstance();
    }
}

上述代码借助Class<T> 参数并通过反射来实例化 T 类型，使用的时候，也必须传入Class<T>。例如：

Pair<String> pair = new Pair<>(String.class);

桥方法被合成来保持多态

《核心技术 卷I》P318

class DateInterval extends Pair<LocalDate>{
    public void setSecond(LocalDate second){
        if (second.compareTo(getFirst()) >= 0) {
            super.setSecond(second);
        }
    }
 }

擦除后变成

class DateInterval extends Pair{
   public void setSecond(LocalDate second){
      ...
   }
}

存在另一个从 Pair 继承的 setSecond方法，即public void setSecond(Object second)
考虑下面的程序

DateInterval interval = new DateInterval(...);
Pair<LocalDate> pair = interval;//ok---assigned to superclass
pair.setSecond(aDate);

这里，希望对setSecond的调用具有多态性，并调用最合适的那个方法。
类型擦除与多态发生了冲突，要解决这个问题，就需要编译器在DateInterval类中生成一个桥方法

public void setSecond(Object second){
	setSecond((Date) second);
}

pair.setSecond(aDate)语句执行如下：变量pair已经声明为类型Pair<LocalDate>，有一个简单方法setSecond(Object)(擦拭后)。
虚拟机用pair引用的对象调用这个方法，这个对象是DateInterval类型的，因而将会调用DateInterval.setSecond(Object)方法，这个方法是合成的桥方法。它调用DateInterval.setSecond(Date)。

要想支持擦除的转换，就需要强行限制一个类或类型变量不能同时成为两个接口类型的子类，而这两个接口是同一接口的不同参数化

例如，下述代码是非法的

class Employee implements Comparable<Employee>{...}
class Manager extends Employee implements Comparable<Manager>
{...}//Error

Manager会实现Comparable<Employee>和Comparable<Manager>，这是同一接口的不同参数化

不恰当的覆写方法

有些时候，一个看似正确定义的方法会无法通过编译。例如：

public class Pair<T> {
    public boolean equals(T t) {
        return this == t;
    }
}

考虑一个Pair<String>，从概念上讲，它有两个equals方法：

boolean equals(String)//defined in Pair<T>
boolean equals(Object)//inherited from Object

定义的equals(T t)方法实际上会被擦拭成equals(Object t)，而这个方法是继承自 Object 的，与Object.equals方法发生冲突。编译器会阻止一个实际上会变成覆写的泛型方法定义。

换个方法名，避开与Object.equals(Object)的冲突就可以成功编译：

public class Pair<T> {
    public boolean same(T t) {
        return this == t;
    }
}

泛型继承

在继承了泛型类型的情况下，子类可以获取父类的泛型类型。例如：IntPair可以获取到父类的泛型类型 Integer。获取父类的泛型类型代码比较复杂：

public class Main {
    public static void main(String[] args) {
        Class<IntPair> clazz = IntPair.class;
        Type t = clazz.getGenericSuperclass();
        if (t instanceof ParameterizedType) {
            ParameterizedType pt = (ParameterizedType) t;
            Type[] types = pt.getActualTypeArguments(); // 可能有多个泛型类型
            Type firstType = types[0]; // 取第一个泛型类型
            Class<?> typeClass = (Class<?>) firstType;
            System.out.println(typeClass); // Integer
        }

    }
}

class Pair<T> {
    private T first;
    private T last;
    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() {
        return first;
    }
    public T getLast() {
        return last;
    }
}

class IntPair extends Pair<Integer> {
    public IntPair(Integer first, Integer last) {
        super(first, last);
    }
}

因为 Java 引入了泛型，所以，只用 Class 来标识类型已经不够了。

Class类，描述具体类型
TypeVariable接口，描述类型变量（如T extends Comparable<? super T>）
WildcardType接口，描述泛型类或接口类型，(如Comparable<? super T>)
GenericArrayType接口，描述泛型数组(如T[])

实际上， Java 的类型系统结构如下：

extends通配符

public class Main {
    public static void main(String[] args) {
        Pair<Integer> p = new Pair<>(123, 456);
        int n = add(p);
        System.out.println(n);
    }

    static int add(Pair<Number> p) {
        Number first = p.getFirst();
        Number last = p.getLast();
        return first.intValue() + last.intValue();
    }

}

class Pair<T> {
    private T first;
    private T last;
    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() {
        return first;
    }
    public T getLast() {
        return last;
    }
}

直接运行，会得到一个编译错误：

incompatible types: Pair<Integer> cannot be converted to Pair<Number>

原因很明显，因为Pair<Integer>不是Pair<Number>的子类，因此，add(Pair<Number>)不接受参数类型Pair<Integer>
就像List<Integer>不是List<Number>的子类一样，List<Integer>是Collection<Integer>的子类

将 add()方法改成如下代码

static int add(Pair<? extends Number> p) {
        Number first = p.getFirst();
        Number last = p.getLast();
        return first.intValue() + last.intValue();
    }

这种使用<? extends Number>的泛型定义称之为上界通配符（Upper Bounds Wildcards），即把泛型类型 T 的上界限定在 Number
除了可以传入Pair<Integer>类型，我们还可以传入Pair<Double>类型，Pair<BigDecimal>类型等等，因为Double和BigDecimal都是Number的子类。了。
如果我们考察对Pair<? extends Number>类型调用getFirst()方法，实际的方法签名变成了：

<? extends Number> getFirst();

即返回值是 Number 或 Number 的子类，因此，可以安全赋值给 Number 类型的变量：

Number x = p.getFirst();//OK
Integer x = p.getFirst();//Error

这是因为实际的返回类型可能是 Integer，也可能是 Double 或者其他类型，编译器只能确定类型一定是 Number 的子类（包括 Number 类型本身），但具体类型无法确定。

我们再来考察一下Pair<T>的set方法：

public class Main {
    public static void main(String[] args) {
        Pair<Integer> p = new Pair<>(123, 456);
        int n = add(p);
        System.out.println(n);
    }

    static int add(Pair<? extends Number> p) {
        Number first = p.getFirst();
        Number last = p.getLast();
        p.setFirst(new Integer(first.intValue() + 100));
        p.setLast(new Integer(last.intValue() + 100));
        return p.getFirst().intValue() + p.getFirst().intValue();
    }

}

class Pair<T> {
    private T first;
    private T last;

    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }

    public T getFirst() {
        return first;
    }
    public T getLast() {
        return last;
    }
    public void setFirst(T first) {
        this.first = first;
    }
    public void setLast(T last) {
        this.last = last;
    }
}

不出意外，我们会得到一个编译错误：

incompatible types: Integer cannot be converted to CAP#1
where CAP#1 is a fresh type-variable:
    CAP#1 extends Number from capture of ? extends Number

编译错误发生在p.setFirst()传入的参数是 Integer 类型。既然 p 的定义是Pair<? extends Number>，那么setFirst(? extends Number)为什么不能传入 Integer ？

原因还在于擦拭法。如果我们传入的 p 是Pair<Double>，显然它满足参数定义Pair<? extends Number>，然而，Pair<Double>的setFirst()显然无法接受 Integer 类型。

这就是<? extends Number>通配符的一个重要限制：方法参数签名setFirst(? extends Number)无法传递任何 Number 类型给setFirst(? extends Number)。

这里唯一的例外是可以给方法参数传入 null：

p.setFirst(null); // ok, 但是后面会抛出NullPointerException
p.getFirst().intValue(); // NullPointerException

不能构造泛型数组

更多请看《核心技术卷一》P323
数组本身也有类型，用来监控存储在虚拟机中的数组。这个类型会被擦除

public static <T extends Comparable> T[] minmax(T[] a){
	T[] mm = new T[2];
	...
	//Error
} 

类型擦除会让这个方法永远构造 Comparable[2]数组

extends通配符的作用

如果我们考察Java标准库的java.util.List接口，它实现的是一个类似“可变数组”的列表，主要功能包括：

public interface List<T> {
    int size(); // 获取个数
    T get(int index); // 根据索引获取指定元素
    void add(T t); // 添加一个新元素
    void remove(T t); // 删除一个已有元素
}

现在，让我们定义一个方法来处理列表的每个元素：

int sumOfList(List<? extends Integer> list) {
    int sum = 0;
    for (int i=0; i<list.size(); i++) {
        Integer n = list.get(i);
        sum = sum + n;
    }
    return sum;
}

为什么我们定义的方法参数类型是List<? extends Integer>而不是List<Integer>？

从方法内部代码看，传入List<? extends Integer>或者List<Integer>是完全一样的，但是，注意到List<? extends Integer>的限制：

• 允许调用get()方法获取 Integer 的引用；
• 不允许调用set(? extends Integer)方法并传入任何 Integer 的引用（null 除外）。

因此，方法参数类型List<? extends Integer>表明了该方法内部只会读取 List 的元素，不会修改 List 的元素（因为无法调用add(? extends Integer)、remove(? extends Integer)这些方法。换句话说，这是一个对参数List<? extends Integer>进行只读的方法（恶意调用 set(null) 除外）。

super通配符

考察下面的set方法：

void set(Pair<Integer> p, Integer first, Integer last) {
    p.setFirst(first);
    p.setLast(last);
}

传入Pair<Integer>是允许的，但是传入Pair<Number>是不允许的。

我们使用super通配符来改写这个方法：

public class Main {
    public static void main(String[] args) {
        Pair<Number> p1 = new Pair<>(12.3, 4.56);
        Pair<Integer> p2 = new Pair<>(123, 456);
        setSame(p1, 100);
        setSame(p2, 200);
        System.out.println(p1.getFirst() + ", " + p1.getLast());
        System.out.println(p2.getFirst() + ", " + p2.getLast());
    }

    static void setSame(Pair<? super Integer> p, Integer n) {
        p.setFirst(n);
        p.setLast(n);
    }

}

class Pair<T> {
    private T first;
    private T last;

    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }

    public T getFirst() {
        return first;
    }
    public T getLast() {
        return last;
    }
    public void setFirst(T first) {
        this.first = first;
    }
    public void setLast(T last) {
        this.last = last;
    }
}

考察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。
唯一可以接收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 的引用。

这个copy()方法的定义就完美地展示了extends和super的意图：

• copy()方法内部不会读取dest，因为不能调用dest.get()来获取 T 的引用；

• copy()方法内部也不会修改src，因为不能调用src.add(T)。

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>。

无限定通配符

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;
}

<?>通配符有一个独特的特点，就是：Pair<?>是所有Pair<T>的超类：

public class Main {
    public static void main(String[] args) {
        Pair<Integer> p = new Pair<>(123, 456);
        Pair<?> p2 = p; // 安全地向上转型
        System.out.println(p2.getFirst() + ", " + p2.getLast());
    }

泛型和反射

不能实例化类型变量

Java的部分反射API也是泛型。例如：Class<T>就是泛型：
Class 类本身就是泛型。例如，String.class是一个Class<String>的实例（事实上，它是唯一的实例）。

不能使用像new T(...),new T[...]或T.class这样的表达式中的类型变量。例如，下面的Pair<T>构造器就是非法的：

public Pair() {
	first = new T();
	second = new T();
}//Error

在JAVA SE 8 之后，最好的解决方法是让调用者提供一个构造器表达式。例如：

Pair<String> p = Pair.makePair(String::new)

makePair方法接收一个Supplier<T>，这是一个函数式接口，表示一个无参数而且返回类型为 T 的函数：

puclic static <T> Pair<T> makePair(Supplier<T> constr){
	return new Pair<>(constr.get(),constr.get());
}

比较传统的解决方法是通过反射调用Class.newInstance方法来构造泛型对象，必须向下面这样设计 API 以便得到一个 Class 对象：

public static <T> Pair<T> makePair(Class<T> c1){
	try{
		return new Pair<>(c1.newInstance,c1.newInstance);
	}catch(Exception e){
		return null;
	}
}

这个方法可以这样调用

Pair<String> p = Pair.makePair(String.class);

// compile warning:
Class clazz = String.class;
String str = (String) clazz.newInstance();

// no warning:
Class<String> clazz = String.class;
String str = clazz.newInstance();

构造方法Constructor<T>也是泛型：

Class<Integer> clazz = Integer.class;
Constructor<Integer> cons = clazz.getConstructor(int.class);
Integer i = cons.newInstance(123);

我们可以声明带泛型的数组，但不能用new操作符创建带泛型的数组：

Pair<String>[] ps = null; // ok
Pair<String>[] ps = new Pair<String>[2]; // compile error!

可以声明通配类型的数组，然后进行类型转换：

@SuppressWarnings("unchecked")
Pair<String>[] ps = (Pair<String>[]) new Pair<?>[2];

使用泛型数组要特别小心，因为数组实际上在运行期没有泛型，编译器可以强制检查变量 ps，因为它的类型是泛型数组。但是，编译器不会检查变量arr，因为它不是泛型数组。因为这两个变量实际上指向同一个数组，所以，操作arr可能导致从ps获取元素时报错，例如，以下代码演示了不安全地使用带泛型的数组：

Pair[] arr = new Pair[2];
Pair<String>[] ps = (Pair<String>[]) arr;

ps[0] = new Pair<String>("a", "b");
arr[1] = new Pair<Integer>(1, 2);

// ClassCastException:
Pair<String> p = ps[1];
String s = p.getFirst();

要安全地使用泛型数组，必须扔掉arr的引用：

@SuppressWarnings("unchecked")
Pair<String>[] ps = (Pair<String>[]) new Pair[2];

上面的代码中，由于拿不到原始数组的引用，就只能对泛型数组ps进行操作，这种操作就是安全的。

带泛型的数组实际上是编译器的类型擦除：

Pair[] arr = new Pair[2];
Pair<String>[] ps = (Pair<String>[]) arr;

System.out.println(ps.getClass() == Pair[].class); // true

String s1 = (String) arr[0].getFirst();
String s2 = ps[0].getFirst();

所以我们不能直接创建泛型数组T[]，因为擦拭后代码变为Object[]
必须借助Class<T>来创建泛型数组

T[] createArray(Class<T> cls) {
    return (T[]) Array.newInstance(cls, 5);
}

我们还可以利用可变参数创建泛型数组T[]：

public class ArrayHelper {
    @SafeVarargs
    static <T> T[] asArray(T... objs) {
        return objs;
    }
}

String[] ss = ArrayHelper.asArray("a", "b", "c");
Integer[] ns = ArrayHelper.asArray(1, 2, 3);

谨慎使用泛型可变参数
在上面的例子中，我们看到，通过：

static <T> T[] asArray(T... objs) {
    return objs;
}

似乎可以安全地创建一个泛型数组。但实际上，这种方法非常危险。以下代码来自《Effective Java》的示例：

public class Main {
    public static void main(String[] args) {
        String[] arr = asArray("one", "two", "three");
        System.out.println(Arrays.toString(arr));
        // ClassCastException:
        String[] firstTwo = pickTwo("one", "two", "three");
        System.out.println(Arrays.toString(firstTwo));
    }

    static <K> K[] pickTwo(K k1, K k2, K k3) {
        return asArray(k1, k2);
    }

    static <T> T[] asArray(T... objs) {
        return objs;
    }

}

直接调用asArray(T...)似乎没有问题，但是在另一个方法中，我们返回一个泛型数组就会产生ClassCastException，原因还是因为擦拭法，在pickTwo()方法内部，编译器无法检测K[]的正确类型，因此返回了Object[]。

如果仔细观察，可以发现编译器对所有可变泛型参数都会发出警告，除非确认完全没有问题，才可以用@SafeVarargs消除警告。

总结

1.Java的泛型是采用擦拭法实现的

• 编写泛型时，需要定义泛型类型<T>；

• 静态方法不能引用泛型类型<T>，必须定义其他类型（例如<K>）来实现静态泛型方法（使用<T>也能通过编译）；

• 泛型可以同时定义多种类型，例如Map<K, V>。

擦拭法决定了泛型<T>：

• 不能是基本类型，例如：int；

• 不能获取带泛型类型的Class，例如：Pair<String>.class；

• 不能判断带泛型类型的类型，例如：x instanceof Pair<String>；

• 不能实例化T类型，例如：new T()。

• 泛型方法要防止重复定义方法，例如：public boolean equals(T obj)；

• 子类可以获取父类的泛型类型<T>。

2.使用类似<? extends Number>通配符作为方法参数时表示：

• 方法内部可以调用获取Number引用的方法，例如：Number n = obj.getFirst()；

• 方法内部无法调用传入Number引用的方法（null除外），例如：obj.setFirst(Number n);。

即一句话总结：使用extends通配符表示可以读，不能写。

3.使用类似<T extends Number>定义泛型类时表示：

• 泛型类型限定为 Number 以及 Number 的子类。

一个类型变量或通配符可以有多个限定，例如：

T extends Comparabel & Serializable

4.使用类似<? super Integer>通配符作为方法参数时表示：

• 方法内部可以调用传入 Integer 引用的方法，例如：obj.setFirst(Integer n)

• 方法内部无法调用获取 Integer 引用的方法（ Object 除外），例如：Integer n = obj.getFirst()

即使用 super 通配符表示只能写不能读。

5.使用 extends 和 super 通配符要遵循PECS(Producer Extends Consumer Super)原则。

6.无限定通配符<?>很少使用，可以用<T>替换，同时它是所有<T>类型的超类。

7.部分反射API是泛型，例如：Class<T>，Constructor<T>；

• 可以声明带泛型的数组，但不能直接创建带泛型的数组，必须强制转型；

• 可以通过Array.newInstance(Class<T>, int)创建T[]数组，需要强制转型；

• 同时使用泛型和可变参数时需要特别小心。