泛型擦除机制

一、泛型的引入

我们想求两个数的最大值

public static void func(int n,int m) {
        System.out.println(n > m ? n : m);
    }
    public static void main(String[] args) {
        func(2,3);
        func(1.5,2.5);
    }
1
2
3
4
5
6
7

但我们方法就写死了，只能求整形的最大值，那我们要求两个浮点数的呢，两个对象的呢?
泛型的出现：

集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个参数，这个类型参数叫做泛型。Collection，List，ArrayList 这个就是类型参数，即泛型

Object类是所有类的父类，它可以接收任意类型的数据，这里以接受String类型为例，在直接接收obj类型时，会报错。

public static void main(String[] args) {
        Object obj = new Object();
        obj = "dachang";
        String str = (String)obj;
    }
1
2
3
4
5

泛型的主要目的：就是指定当前的容器，要持有什么类型的对象。让编译器去做检查

二、基本数据类型和对应包装类

在Java中，由于基本类型不是继承于Object，为了在泛型代码中可以支持基本类型，Java给每个基本类型都对应了一个包装类型。

大部分基本类型的包装类都是首字母大写，除了Int的包装类为Integer,char的包装类为Character

三、初使用泛型

实现一个类，类中包含一个数组成员，使得数组中可以存放任何类型的数据，也可以根据成员方法返回数组中某个下标的值？

class InitArray{
    public Object[] arr = new Object[10];

    public Object getPos(int pos) {
        return arr[pos];
    }

    public void setVal(int pos,Object val) {
        this.arr[pos] = val;
    }
}
public static void main(String[] args) {
        InitArray initArray = new InitArray();
        initArray.setVal(0,true);//可以存放boolean类型
        initArray.setVal(1,10.5);//可以存放double类型
        boolean b = initArray.getPos(0);//编译报错
        double f = initArray.getPos(1);//编译报错
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Object数组任何类型数据都可以存放，但在进行接受时，编译器就会报错，必须要进行类型转换。
在更多的情况下，我们还是希望它只能放同种类型。需要什么类型，我们传入什么参数就可以，泛型就是为此而生
用泛型实现：

class InitArray<T> {
    public T[] arr = (T[])new Object[10];

    public T getPos(int pos) {
        return arr[pos];
    }

    public void setVal(int pos,T val) {
        this.arr[pos] = val;
    }
}
public static void main(String[] args) {
        InitArray<Integer> initArray = new InitArray<>();
        initArray.setVal(0,10);
        initArray.setVal(1,5);
        int a = initArray.getPos(0);
        int b = initArray.getPos(1);
        System.out.println(a);
        System.out.println(b);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

我们发现这里我们没有进行强制类型转换，并且顺利输出了。
代码解释：

1.
这里的InitArray是泛型类，代表占位符，就表示当前类是一个泛型类，大家不必去追问为啥是T，这里只是一个变量名而已，常见的还有:

2.
不再需要强制类型转换。
3.
编译器会帮助我们检查代码，如果类型不一致会报错。
4.
类型后面的指定当前类型。
5.无法new 一个泛型类型的数组。

T[] t = new T[10];
1

所以不存在上面这种方式。

四、泛型的编译

1 擦除机制

我们查看一下字节码文件

在编译的过程中我们发现所有的T都被替换为了Object，我们把这种机制称为: 擦除机制。
编译器生成的字节码在运行期间不包含任何泛型的类型信息。

2 为什么不能实例化泛型类型数组？

根据擦除机制可知，在编译阶段所有的T被替换为了Object，那为什么，T[] ts = new T[5]; 是不对的，编译的时候，替换为Object，不是相当于：Object[] ts = new Object[5]吗？

由于无法创建泛型数组，我们换个例子去验证

class MyArray<T> {
    public T[] arr = (T[])new Object[10];

    public T getPos(int pos) {
        return this.arr[pos];
    }

    public void setVal(int pos,T val) {
        this.arr[pos] = val;
    }

    public T[] getArr() {
        return arr;
    }
}
public static void main(String[] args) {
        MyArray<Integer> myArray = new MyArray<>();
        Integer[] arr = myArray.getArr();
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

替换之后，将Object[ ]传给Integer[ ]，因为Object数组里可能存放的是任何类型的数据，直接转给Integer数组是不安全的，所以程序报类型转换异常。具体来说，数组是在运行时存储和检查类型信息，而泛型是在编译时检查错误，如果泛型可以创建数组，那么这里就有很大的安全隐患。

public T[] arr = (T[])new Object[10];
1

那这样使用好吗？ 是的不好，但我们目前学习的知识只能使用到这，其实这样使用也会有安全隐患，下面举一个安全的使用方法，了解即可:

class MyArray<T> {
    public T[] arr;

    public MyArray() {

    }

    //这里通过反射，创建一个类型为指定类型的数组，了解即可。
    public MyArray(Class<T> clazz,int capacity) {
        arr = (T[]) Array.newInstance(clazz,capacity);
    }

    public T getPos(int pos) {
        return this.arr[pos];
    }

    public void setVal(int pos,T val) {
        this.arr[pos] = val;
    }

    public T[] getArr() {
        return arr;
    }
}
public static void main(String[] args) {
        MyArray<Double> myArray = new MyArray<>(Double.class,10);
        Double[] arr = myArray.getArr();
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

这样就可以顺利转换了，避免了安全隐患。

3 类型擦除，一定是把T变为Object吗？

不是的，目前我们看到的确实T全部变为了Object，但当T指定了类型参数的上界的话，则使用这个上界，下一篇博客我会具体介绍泛型上界。