泛型本质 - 简书

Author JYBlog
Email jcAuthor@163.com
本博客GitHub开源(jcNaruto/JYBlog)
JYBlog每周五，周三公众号等多平台同步更新，欢迎讨论交流~

泛型（generics, genericity）又称为参数化类型（parameterized types）或模板（templates) 。
是一种通用的复用技术，不同的语言有不同的实现。
泛型在Java语言中通过编译器擦除实现，通过编译期的检查，Java程序也变得更加安全。

1.概述

泛型是一种通用的技术，是代码模板、是一种复用技术（区别于继承），当你运用泛型时，你将拥有许多不同的类型，并得以相同的演算法（如排序、搜寻）作用在它们身上。
在Java中，泛型也是一种编译时类型安全检测机制，你可以在编译期强制检查集合中的元素是否都为同一类型，也可以通过泛型通配符强制参数要实现某些接口（sort方法要实现Comparable原理）。

ArrayList实际上就是会自动扩容的Object[],此时假设放入其中是String类型，取出来时可以强制转换为String，但如果强制转化为其他就会抛出 ClassCastException 。

加入泛型之后，只能存入String类型，也只能取出String类型，如果尝试加入或者取出其他类型，编译器会直接报错，避免了运行期的异常。

public class ArrayList ...{
    private Object[] array;
    private int size;
    public void add(Object e) {...}
    ...
}
arrayList.add("123");
Object obj = arrayList.get(0);
String obj = (String)arrayList.get(0);
//ClassCastException
Integer obj = (Integer)arrayList.get(0);

编写了一套排序工具类,方法中间是排序的逻辑，有多个类都符合这个排序逻辑，不用为每个类都写一个排序类，直接用泛型复用。

public class SortUtil{
    public static <K> void mySort(K k){
        xxxxx
    }
}
SortUtil.mySort(new Integer());
SortUtil.mySort(new Double());

2.泛型实现原理

前面提过泛型是一种通用的复用技术，不同的语言有不同的实现。在Java中使用了擦拭法( Type Erasure )。

擦拭法的含义就是所有的工作都是编译器做的，jvm对泛型一无所知。

这是程序员和编译器看到的代码

public class JYBlog<T>{
    private T t;
    public void set(T t){
        xxxx
    }
    public T get(){
        xxxxx
    }
}
JYBlog<Integer> test = new JYBlog<>();
test.set(123);
Integer xx = test.get();

这是虚拟机看到的代码

public class JYBlog{
    private Object obj;
    public void set(Object t){
        xxxx
    }
}
JYBlog test = new JYBlog();
test.set(123);
Integer xx = (Integer)test.get();

也就是说编译器在编译时会检查是否符合泛型要求，如果符合的话会让T类型指向Object并且在获取泛型的时候进行一定安全的强制类型转换，虚拟机对此一无所知。

3.擦拭法局限

T不能是基本类型，Object类型无法持有基本类型，不然编译报错。
因为最终虚拟机实际是用T指向了Object，也就是说JYBlog<Integer>和JYBlog<Double>在虚拟机层面都是JYBlog，只不过编译器在getT的时候安全的强制转换了，JYBlog<Integer>.class和JYBlog<Double>.class是同一个，此外编译器还规定，条件表达式中无法判断带泛型的class，因为都是同一个。
在模板代码中不能实例化T，因为擦拭之后变为new Object();这样就丢失了具体的T。如果模板代码中真的要实例化T可以用反射
```
public class JYBlog<T>{
 private T t;
    public JYBlog(Class<T> clazz) {
        T = clazz.newInstance();
    }
}
```
泛型方法要防止重复定义方法，擦拭后就会复写Object的equals，编译器会报错一旦擦拭之后形成复写

public boolean equals(T obj)；

因为擦拭法，我们无法从JYBlog<Integer> y，y实例中获取Integer但是子类可以获取父类的泛型类型T。

4.泛型类、方法、接口

4.1泛型类、泛型方法

将泛型定义在类名后，在实例方法，属性中可以直接使用，不需要定义，但是静态方法上的泛型需要在静态方法上声明，不能直接使用。程序员在使用该类时，根据不同情况传入不同类型。

public class SortUtil<T>{
    private T t;
    public void set(T t){
        xxxx
    }
    public static <K> void mySort(K k){
        xxxxx
    }
}
SortUtil.mySort(xxx);
new SortUtil<xxx>();

注：<T>,<E>,<K,V>中那些字母没有实际的意思，你可以替换为你想用的字符，但是一般习惯集合中用E，表示元素，其他用T，但是<?>中？代表了通配符中的一种很少使用。

4.2泛型接口

public interface Comparable<T> {
    int compareTo(T o);
}

注：接口是规范，泛型接口的意义就是该规范以后会被不同的类所遵守。

5.通配符和PECS原则

注意：因为擦拭法，所以JYBlog<Integer>和JYBlog<Number>不是子类

void get(ArrayList<Integer> list){
    Number = list.get();
}
add(new ArrayList<Integer>());
//complie error
add(new ArrayList<Double>());

但是从add方法内部可以看出get之后确实可以指向Number，但是由于编译器泛型检查严格，所以禁止这样做，但是我们不能要为每个泛型参数都编写一个方法，因此可以使用extends通配符修饰方法参数，表示可以传入T类型为Number子类的参数

5.1extends通配符

void get(ArrayList<? extends Integer> list){
    Number = list.get();
    list.add(Double);
}
add(new ArrayList<Integer>());
add(new ArrayList<Double>());

此时发现get方法内部list.add一定会出错，因为传入的是Integer泛型的list，无法add double ，因此当extends（上界通配符修饰）修饰方法参数的时候就限制方法内不能修改通配符修饰的参数（null）可以，表示由编译器保证方法内部代码对于参数只能读，不能写。

注：

extends通配符也可以修饰类，public class JYBlog<T extends Number> { ... }，这样做会限制T的类型必须是Number或其子类。观看sort的源码就发现sort中通过extends通配符在编译期就要求排序集合的T类型必须实现Comparable接口。
<? extends String>中表示方法参数中的T必须是必须是String的子类或者本身，但是String源码中final修饰class无法继承。也就是参数的泛型必须是String本身。

5.2 super通配符

void set(ArrayList<? super Integer> list,Integer x,Integer y){
    list.add(x);
    //除了返回Object会compile error
    list.get();
}

super通配符修饰方法参数的时候表示，参数的T类型必须是指定类型本身或者其父类。
在super通配符修饰方法参数修饰的方法内部，执行对应的get方法会编译报错（除了返回Object），表示由编译器保证方法内部代码对于参数只能写，不能读。
super通配符无法修饰类

5.3 PECS原则

extends，super通配符是由编译器保证的允许读不允许写（null除外），另一个是允许写不允许读（Object除外），为了方便记忆可以product生产者要读取元素出来使用Extends，消费者要写入使用Super通配符。

5.4 通配符总结

通配符可以限定泛型中的T类型的上界或者下界，如果修饰方法参数还可以在编译期保证方法内只进行读写操作中的一种。

5.5无界通配符

刚刚修饰在方法参数上的上下界通配符其实是限定了传入的参数的T类型的上下界，如果想要指定T可以为任何类型就可以使用<?>,但是方法内部不能读也不能写，只能做一些和null相关的动作。

另外值得注意的是JYBlog<?>是所有JYBlog<T>的超类

6.补充

补充部分待研究到具体章节时会归来补充

反射中大量用到泛型
泛型数组存在的意义是什么，数组编译器会检查类型安全，且只能存一种类型，泛型的安全和复用特性完全不需要啊
同时使用泛型和可变参数时需要特别小心