Java泛型，这一篇就够了

1. 为什么我们需要泛型

现实世界中我们经常遇到这样一种情况，同一个算法/数据结构适用于多种数据类型，我们不想为每一种类型单独写一个实现。举个例子来说，我们有一个Pair类型，存储key、value两个字段，代码如下。如果有一天，我想存储Integer类型的key, Date类型的Value，这个时候，我需要重新定义一个Pair类型。

public class Pair {
    private String key;
    private String value;
}
public class PairIntDate {
    private Integer key;
    private Date value;
}

存储的需求是多种多样的，慢慢地我们会有一大堆PairXxxYyy类型，重复定义的Class会大量冗余。于是人们想到了第二个方案，用Object引用存储，使用的时候再做强制类型转换。

public static class Pair {
    public Object key;
    public Object value;
}

使用的时候，写入可以直接赋值，读取的时候强制类型转换。Java的ArrayList就是这么做的，通过维护一个Object[] elementData实现数据的存储。

Pair p = new Pair();
p.key = "stringKey";
p.key = Integer.valueOf(1);
String key = (String) p.key;

这种方法带来了两个问题：

读取时要强制类型转换
没有编译检查，能写入任意类型数据，导致读取时失败

Java 5开始引入的泛型就是为了解决这个问题的，使用泛型时，我们可以这样定义Pair并使用，完美的解决了上面两个问题。

public class RawArray {



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

        public K getKey() {
            return key;
        }

        public void setKey(K key) {
            this.key = key;
        }

        public V getValue() {
            return value;
        }

        public void setValue(V value) {
            this.value = value;
        }
    }
    public static void main(String[] args) {
        Pair<String, Integer> pair = new Pair<>();
        pair.setKey("pairKey");
        pair.setValue(Integer.valueOf(1));
        Integer localValue = pair.getValue();
    }      

}

2. 泛型的实现原理

2.1 类型擦除

JVM内并没有泛型这个概念，所有的类型都是普通的类。以上面的RawArray为例，我们看看Java内部是怎么做的。通过javap命令查看class文件的字节码，命令如下：

javap -verbose RawArray$Pair.class
javap -verbose RawArray.class

Pair类的字节码如图，实际存在的字段key、value都是Object类型，getKey方法实际返回值类型是Object，setKey的入参实际类型也是Object类型，这就是我们经常说的类型擦除，泛型会擦除到定义的上界。

下面我们看看main方法里是如何使用Pair对象的，调用setKey方法时的类型检测是编译器行为，在字节码中并没有体现。getValue方法返回的是Object类型对象，编译器插入了checkcast命令替我们完成类类型转换。

2.2 桥接方法

从上一节学习的Pair字节码我们知道，Pair类的setKey方法的参数、getKey方法的返回值都被擦除为Object类型。如果我们继承Pair, 并重写setKey、getKey方法。

public static class ExtendPair extends Pair<String, Integer> {

    public String getKey() {
        return super.getKey();
    }

    public void setKey(String key) {
        super.setKey(key);
    }
}

回忆一下Java的基础知识， Java的方法签名指的是方法名和参数列表，父类Pair有两个方法：

Object getKey()
void setKey(Object)

子类ExtendPair重写/新增了两个方法

String getKey()
void setKey(String key)

两个setKey的方法签名不同，实际是两个重载方法，而getKey方法签名相同，返回值却不同，Java语言规范内是不允许的。如果我将ExtendPair向上转型为Pair并调用getKey和getValue方法会怎么样呢？通过阅读ExtendPair的字节码，我们找到了答案。

Java语言规范中不允许同时定义String getKey()、Object getKey()两个签名相同的方法，但是字节码层面是允许的，通过ExtendPair的字节码，生成的Object getKey()会调用String getKey()方法，这个方法被称为桥接方法，向上转型为Pair后，实际调用的是Object getKey()方法，签名和父类完全一致，然后由它转发个String getKey()方法。

setKey的桥接方法实现和getKey如出一辙，这里就不详细讲解了，有兴趣可以看看对应的字节码。值得一提的是，在类继承时提到的协变返回类型也是通过桥接方法实现的。

3. Java泛型的定义

3.1 泛型方法

之前的案例里我们已经看到泛型类( RawArray$Pair)的定义了，泛型类的类型参数不能用到静态方法上。我们来看一下泛型方法的定义，类型参数放到修饰词之后，返回值之前，看示例的of方法。通常调用泛型方法时我们不需要明确地知道类型参数，编译器自己能通过入参/返回值接收对象的引用推断出类型参数。

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

    public static <T,S> Pair<T,S> of(T k, S v) {
        Pair<T,S> r = new Pair<>();
        r.key = k;
        r.value = v;
        return r;
    }
}

通过这么使用我们定义的泛型方法

var aPair = Pair.of("pairKey",1);
System.out.println(aPair.getKey());

3.2 类型限定

讲Java泛型的原理的时候，我们讲过Java会将泛型的类型擦除，最后存储的是Object类型的引用。Java并不支持动态语言里的Duking Type，这个时候如果我们想调用Pair对象里key、value对象上的方法，我们只能调用Object上定义的方法。如果我们想调用指定类型下的方法，就需要用到类型限定。

我们通过一个例子来看，假设我们有一个Range类，接收两个值来表示一段区间，这两个值必须支持比较(Comparable)，同时我们希望在较小的实例上执行某些操作(包装在Runnbale中)，代码如下

public static class Range<T extends Comparable<T> & Runnable> {
    private T min;
    private T max;
    

    public static <S extends Comparable<S> & Runnable> Range<S> of(S s1, S s2) {
        if (s1.compareTo(s2) > 0) {
            S temp = s1;
            s1 = s2;
            s2 = temp;
        }
        s1.run();
        Range<S> range = new Range<>();
        range.min = s1;
        range.max = s2;
        return range;
    }
}

示例中的S extends Comparable<S> & Runnable就是我们说的类型限定，如果有多个限定类型用&号分隔，Java允许类继承一个父类多个接口，指定类型限定的时候，通过extends关键字，后面接一个0或1个父类，0或N个接口，如果有的话，父类限定要放到最前面。

可以看到Comparable.compareTo方法、Runnable.run方法都可以直接在泛型方法内部调用，虽然还是要求用接口做类型限定，比起Duking Type还略有缺憾，但应该说已经不错了。

3.3 通配符类型

假设我们有3个类，Animal表示动物，Dog是Animal的子类，Cage是一个泛型类，可以持有一个对象的引用，代码如下

public static class Animal {
}

public static class Dog extends Animal {
}

public static class Cage<T> {
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

各个类直接的关系如下图，Animal和Dog有继承关系，Cage和Cage并没有，最右侧的一列我们稍后再讲。

如果我们一个方法delivery用于投递Cage，如果我们使用Cage调用这个方法，编译器提示Required Cage, Provide Cage

private static void delivery(Cage<Animal> cage)

使用通配符可以解决这个问题，Cage表示持有某个Animal的子类，这个类型可以是Animal，也可以是Dog

private static void delivery(Cage<? extends Animal> cage)

除了子类型限定以外，还有超类型限定，无限定通配符

类型	语法	简记	描述
子类限定	Cage	读	能调Cage.getT方法，用Animal接受返回值；不能调Cage.setT，T是继承Animal的类，不知道确切类型
超类限定	Cage	写	能调Cage.setT方法，用Animal子类做入参；不能调Cage.getT，T是Animal的超类，不知道确切类型
无限定通配符	Cage	读Object	能调Cage.getT方法，用Object接收返回值；不能调Cage.setT，不知道T的确切类型

4. Java泛型的局限

4.1 类型检查只能用于原始类型

由于类型擦除的原因Pair和Pair都会将类型参数擦除到Object，所以这两个泛型类型的实例变量的Class实际是相同的

Pair<Integer,Integer> pi = new Pair<>();
Pair<Long,Long> pl = new Pair<>();
System.out.println(pi.getClass() == pl.getClass());

调用instanceof时，下面两个判断都会发true，而对pi instanceof Pair检查时，会报编译错误。

if (pi instanceof Pair<Integer, Integer>) {
    System.out.println("Pair<Integer,Integer>");
}
if (pi instanceof Pair) {
    System.out.println("Pair");
}

4.2 不能参数化类型数组

不能创建泛型类型的数组，数组会存储元素的类型，通过Class.getComponentType()获取数组元素的类型，Class.getComponentType()只能元素的原始类型，运行时无法做到阻止往Pair[]的数组中添加Pair的元素。但是编译器允许定义泛型数组的变量，定义一个Pair的数组后强制类型转换为泛型数组。

Java不允许我们创建泛型对象的数组，可变参数数组的时候这个限制略有放松，允许我们定义泛型的可变参数列表，下面这段代码是允许的

private void varArgs(Pair<String, Integer>... ps) {
    // code goes here
}

4.3 无法实例化类型变量

因为类型擦除的作用，我们无法通过T.class引用到Class对象，当然更无法通过T.class创建对象的实例。早期我们通过传入Class clazz来完成实例的创建。Java 8之后可以通过函数式接口来创建。

public static class Holder<T> {
    public T makeT() {
        return T.class.newInstance(); // 无法正常允许，不能通过T.class因为到Class对象
    }
    public T makeT(Class<T> clazz) throws Exception {
        return clazz.getConstructor().newInstance();
    }
    public T makeT(Supplier<T> supplier) {
        return supplier.get();
    }
}

泛型数组的创建也可以采用类似的方法，传入Class clazz或者传入一个函数式接口来创建

public static class Holder<T> {
    public T[] makeT(Class<T> clazz) {
        return (T[]) Array.newInstance(clazz, 10);
    }
    public T[] makeT(IntFunction<T[]> make) {
        return make.apply(10);
    }
}
// 调用方式
Holder<String> ss = new Holder<>();
System.out.println(Arrays.toString(ss.makeT(String.class)));
System.out.println(Arrays.toString(ss.makeT(String[]::new)));

4.4 不能定义/抛出/捕获泛型异常

继承自Throwable的类不能是泛型类型，catch的括号里不能用类型变量。下面的throwsAs是CoreJava里的一个示例，通过欺骗编译器允许方法不声明检查型异常。

public static <T extends Throwable> void throwsAs(Throwable t) throws T {
    throw (T) t;
}


public T makeT(Class<T> clazz) {
    try {
        return clazz.getConstructor().newInstance();
    } catch (Throwable t) {
        GenInstance.<RuntimeException>throwsAs(t);
        return null;
    }
}

5. Java泛型的反射

Java反射的信息最终来自.class文件，而在编译的时候我们并不知道类会怎么被使用。假设我们定义了Company>类，使用时Company、Company引用的是同一个Class对象。为了方便讲解，我们定义如下的测试类

public static class KeyNiuTech extends Company<Date> {
}

public static class Company<T extends Comparable<? super T>> {
    private T[] staff;
    private T aStaff;
    public static <O extends Comparable<? super O>> Company<O> of(O o) {
        Company<O> c = new Company<>();
        c.aStaff = o;
        return c;
    }
}

通过查看这两个的字节码可以看到，这两个能拿到的信息的上限，Company能拿到类型参数T以及T的上限Comparable，以及Comparable的类型参数。KeyNiuTech里更有意思一点，KeyNiuTech继承自Company，这里的这个类型Date也被保存了，记不记得我们解析JSON时经常需要传递一个TypeReference的匿名子类？

Java提供了5种类型来支持泛型的泛型，类型之间的关系如下图

我们来看一下每种实现类分别代表着哪种类型的数据

类型	说明	举例
Class	具体类型	KeyNiuTech.class、Company.class
TypeVariable	类型变量	T extends Comparable
WildcardType	通配符	? super T
ParameterizedType	泛型类	Company、Comparable
GenericeArrayType	泛型数组	Company.staff通过Field获取后，读getGenericeType()返回的就是这个类型

最后一个示例结尾，这段代码用于打印类的定义信息

private static StringBuilder classDetail(Class clazz) {
    StringBuilder sb = new StringBuilder();

    int modifier = clazz.getModifiers();
    sb.append(Modifier.toString(modifier)).append(" ");
    sb.append(clazz.getName());

    TypeVariable[] tvs = clazz.getTypeParameters();
    if (tvs != null && tvs.length > 0) {
        sb.append("<");
        for (TypeVariable tv : tvs) {
            sb.append(tv.getName());
            Type[] bounds = tv.getBounds();
            if (bounds != null && bounds.length > 0) {
                sb.append(" extends ");
                for (Type bound : bounds) {
                    sb.append(bound.getTypeName());
                }
            }
        }
        sb.append(">");
    }

    Type superClass = clazz.getGenericSuperclass();
    if (superClass instanceof Class) {
        sb.append(" extends ");
        sb.append(superClass.getTypeName());
    } else if (superClass instanceof ParameterizedType) {
        ParameterizedType pt = (ParameterizedType) superClass;
        sb.append(" extends ");
        sb.append(pt.getRawType().getTypeName());
        sb.append("<");
        Type[] actualTypes = pt.getActualTypeArguments();
        for (Type at : actualTypes) {
            sb.append(at.getTypeName());
        }
        sb.append(">");
    }

    Type[] superInterfaces = clazz.getGenericInterfaces();
    for (Type ifs : superInterfaces) {
    }

    return sb;
}

输出示例

public static com.company.generic.GenericReflect$KeyNiuTech extends com.company.generic.GenericReflect$Company<java.util.Date>