泛型擦除机制

ゝ一纸荒年。 2023-09-27 09:27 29阅读 0赞

![在这里插入图片描述][9442495c5b8e47bdb8f239074aa5ddca.gif_pic_center]

#### 文章目录 ####

*  一、泛型的引入
 *  二、基本数据类型和对应包装类
 *  三、初使用泛型
 *  四、泛型的编译
 *   *  1 擦除机制
     *  2 为什么不能实例化泛型类型数组？
     *  3 类型擦除，一定是把T变为Object吗？

## 一、泛型的引入 ##

我们想求两个数的最大值

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

![在这里插入图片描述][a528f5b8176d4434a66e301edd059975.png]  
但我们方法就写死了，只能求整形的最大值，那我们要求两个浮点数的呢，两个对象的呢?  
**泛型的出现：**

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

![在这里插入图片描述][a605f53cdf404b5ab0bce43a43596360.png]  
Object类是所有类的父类，它可以接收任意类型的数据，这里以接受String类型为例，在直接接收obj类型时，会报错。

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

![在这里插入图片描述][c8e26958ac7342a2a8ba2b7bb63c09c0.png]泛型的主要目的：就是指定当前的容器，要持有什么类型的对象。让编译器去做检查

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

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

<table> 
 <thead> 
  <tr> 
   <th>基本数据类型</th> 
   <th>包装类</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>byte</td> 
   <td>Byte</td> 
  </tr> 
  <tr> 
   <td>short</td> 
   <td>Short</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>Integer</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>Long</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>Float</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>Double</td> 
  </tr> 
  <tr> 
   <td>char</td> 
   <td>Character</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>Boolean</td> 
  </tr> 
 </tbody> 
</table>

大部分基本类型的包装类都是首字母大写，除了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);//编译报错
        }

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

![在这里插入图片描述][320a329583b7469bb01833af21129e36.png]  
我们发现这里我们没有进行强制类型转换，并且顺利输出了。  
代码解释：

1.![在这里插入图片描述][87ea862e4ad84561b0f58e153f64b225.png]  
这里的InitArray是泛型类，代表占位符，就表示当前类是一个泛型类，大家不必去追问为啥是T，这里只是一个变量名而已，常见的还有:

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>表示</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>E</td> 
   <td>Element</td> 
  </tr> 
  <tr> 
   <td>K</td> 
   <td>Key</td> 
  </tr> 
  <tr> 
   <td>V</td> 
   <td>Value</td> 
  </tr> 
  <tr> 
   <td>N</td> 
   <td>Number</td> 
  </tr> 
  <tr> 
   <td>T</td> 
   <td>Type</td> 
  </tr> 
 </tbody> 
</table>

2.![在这里插入图片描述][7c63b192296e4c4091608d2e2cd44feb.png]  
不再需要强制类型转换。  
3.![在这里插入图片描述][7ac01c8de79743c08ae698c2b4d3006a.png]  
编译器会帮助我们检查代码，如果类型不一致会报错。  
4.![在这里插入图片描述][3b04686ff62e4de99c1cf126afb2f428.png]  
类型后面的指定当前类型。  
5.无法new 一个泛型类型的数组。

T[] t = new T[10];

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

## 四、泛型的编译 ##

### 1 擦除机制 ###

我们查看一下字节码文件  
![在这里插入图片描述][05d0793d47b9454baea9ea1e1fcbcf46.png]  
在编译的过程中我们发现所有的T都被替换为了Object，我们把这种机制称为: **擦除机制**。  
编译器生成的字节码在运行期间不包含任何泛型的类型信息。

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

根据擦除机制可知，在编译阶段所有的T被替换为了Object，那为什么，T\[\] ts = new T\[5\]; 是不对的，编译的时候，替换为Object，不是相当于：Object\[\] ts = new Object\[5\]吗？  
![在这里插入图片描述][d45eaad0b6ff439db4d81d098f0cc31c.png]  
由于无法创建泛型数组，我们换个例子去验证

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

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

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

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

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

![在这里插入图片描述][fbc1337b59654a2a813e433a2a18c13a.png]  
这样就可以顺利转换了，避免了安全隐患。

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

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

[9442495c5b8e47bdb8f239074aa5ddca.gif_pic_center]: https://img-blog.csdnimg.cn/9442495c5b8e47bdb8f239074aa5ddca.gif#pic_center
[a528f5b8176d4434a66e301edd059975.png]: https://img-blog.csdnimg.cn/a528f5b8176d4434a66e301edd059975.png
[a605f53cdf404b5ab0bce43a43596360.png]: https://img-blog.csdnimg.cn/a605f53cdf404b5ab0bce43a43596360.png
[c8e26958ac7342a2a8ba2b7bb63c09c0.png]: https://img-blog.csdnimg.cn/c8e26958ac7342a2a8ba2b7bb63c09c0.png
[320a329583b7469bb01833af21129e36.png]: https://img-blog.csdnimg.cn/320a329583b7469bb01833af21129e36.png
[87ea862e4ad84561b0f58e153f64b225.png]: https://img-blog.csdnimg.cn/87ea862e4ad84561b0f58e153f64b225.png
[7c63b192296e4c4091608d2e2cd44feb.png]: https://img-blog.csdnimg.cn/7c63b192296e4c4091608d2e2cd44feb.png
[7ac01c8de79743c08ae698c2b4d3006a.png]: https://img-blog.csdnimg.cn/7ac01c8de79743c08ae698c2b4d3006a.png
[3b04686ff62e4de99c1cf126afb2f428.png]: https://img-blog.csdnimg.cn/3b04686ff62e4de99c1cf126afb2f428.png
[05d0793d47b9454baea9ea1e1fcbcf46.png]: https://img-blog.csdnimg.cn/05d0793d47b9454baea9ea1e1fcbcf46.png
[d45eaad0b6ff439db4d81d098f0cc31c.png]: https://img-blog.csdnimg.cn/d45eaad0b6ff439db4d81d098f0cc31c.png
[466c5697b02d4c87aa26a95bcae350f7.png]: https://img-blog.csdnimg.cn/466c5697b02d4c87aa26a95bcae350f7.png
[fbc1337b59654a2a813e433a2a18c13a.png]: https://img-blog.csdnimg.cn/fbc1337b59654a2a813e433a2a18c13a.png