Java基础之伪泛型和类型擦除

清疚 2024-04-06 14:24 63阅读 0赞

#### Java基础之伪泛型和类型擦除 ####

*  一、理解
 *   *  1、泛型的类型擦除原则
     *  2、无限制类型擦除
     *  3、有限制类型擦除
     *  4、擦除方法定义中的类型参数
 *  二、类型擦除
 *   *  1、原始类型相等
     *  2、通过反射添加其它类型元素
     *  3、类型擦除后保留的原始类型
     *  4、举例

--------------------

## 一、理解 ##

### 1、泛型的类型擦除原则 ###

*  消除类型参数声明，即删除`<>`及其包围的部分。
 *  \-根据类型参数的上下界推断并替换所有的类型参数为原生态类型：如果类型参数是无限制通配符或没有上下界限定则替换为Object，如果存在上下界限定则根据子类替换原则取类型参数的最左边限定类型（即父类）。
 *  为了保证类型安全，必要时插入强制类型转换代码。
 *  自动产生“桥接方法”以保证擦除类型后的代码仍然具有泛型的“多态性”。

### 2、无限制类型擦除 ###

当类定义中的类型参数没有任何限制时，在类型擦除中直接被替换为Object，即形如`<T>`和`<?>`的类型参数都被替换为Object。  
![在这里插入图片描述][58c8f6b19262478cb5e4701649028769.png]

### 3、有限制类型擦除 ###

当类定义中的类型参数存在限制（上下界）时，在类型擦除中替换为类型参数的上界或者下界，比如形如`<T extends Number>`和`<? extends Number>`的类型参数被替换为`Number`，`<? super Number>`被替换为Object。

![在这里插入图片描述][f4f009e854f74bd19d7d42619c09948d.png]

### 4、擦除方法定义中的类型参数 ###

擦除方法定义中的类型参数原则和擦除类定义中的类型参数是一样的，这里仅以擦除方法定义中的有限制类型参数为例。  
![在这里插入图片描述][49bdf701f1fb4635944c471fba375044.png_pic_center]

## 二、类型擦除 ##

### 1、原始类型相等 ###

在这个例子中，我们定义了两个ArrayList数组，不过一个是`ArrayList<String>`泛型类型的，只能存储字符串；一个是`ArrayList<Integer>`泛型类型的，只能存储整数，最后，我们通过list1对象和list2对象的`getClass()`方法获取他们的类的信息，最后发现结果为true。说明泛型类型String和Integer都被擦除掉了，只剩下原始类型。

@Test
        void test1() {
        
            ArrayList<String> list1 = new ArrayList<String>();
            list1.add("abc");
    
            ArrayList<Integer> list2 = new ArrayList<Integer>();
            list2.add(123);
    
            System.out.println(list1.getClass() == list2.getClass()); // true
    
        }

### 2、通过反射添加其它类型元素 ###

在程序中定义了一个`ArrayList`泛型类型实例化为`Integer`对象，如果直接调用`add()`方法，那么只能存储整数数据，不过当我们利用反射调用`add()`方法的时候，却可以存储字符串，这说明了`Integer`泛型实例在编译之后被擦除掉了，只保留了原始类型。

@Test
        void test2() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        
            ArrayList<Integer> list = new ArrayList<Integer>();
    
            list.add(1);  //这样调用 add 方法只能存储整形，因为泛型类型的实例为 Integer
            //list.add("abc");  //因为泛型类型的实例为 Integer，所以会报错
    
            list.getClass().getMethod("add", Object.class).invoke(list, "abc");
    
            for (int i = 0; i < list.size(); i++) {
        
                System.out.println(list.get(i));
            }
    
            System.out.println(list.getClass() == list.getClass()); // true
        }

### 3、类型擦除后保留的原始类型 ###

原始类型Object

class Pair<T> {
          
        private T value;  
        public T getValue() {
          
            return value;  
        }  
        public void setValue(T  value) {
          
            this.value = value;  
        }  
    }

Pair的原始类型为:

class Pair {
          
        private Object value;  
        public Object getValue() {
          
            return value;  
        }  
        public void setValue(Object  value) {
          
            this.value = value;  
        }  
    }

因为在`Pair<T>`中，`T` 是一个无限定的类型变量，所以用Object替换，其结果就是一个普通的类，如同泛型加入Java语言之前的已经实现的样子。在程序中可以包含不同类型的Pair，如`Pair<String>`或`Pair<Integer>`，但是擦除类型后他们的就成为原始的Pair类型了，原始类型都是Object。

### 4、举例 ###

比如: Pair这样声明的话  
那么原始类型就是Comparable。

public class Pair<T extends Comparable> {
        }

在调用泛型方法时，可以指定泛型，也可以不指定泛型:

*  在不指定泛型的情况下，泛型变量的类型为该方法中的几种类型的同一父类的最小级，直到Object
 *  在指定泛型的情况下，该方法的几种类型必须是该泛型的实例的类型或者其子类

public class Test {
          
        public static void main(String[] args) {
          
    
            /**不指定泛型的时候*/  
            int i = Test.add(1, 2); //这两个参数都是Integer，所以T为Integer类型  
            Number f = Test.add(1, 1.2); //这两个参数一个是Integer，一个是Float，所以取同一父类的最小级，为Number  
            Object o = Test.add(1, "asd"); //这两个参数一个是Integer，一个是String，所以取同一父类的最小级，为Object  
    
            /**指定泛型的时候*/  
            int a = Test.<Integer>add(1, 2); //指定了Integer，所以只能为Integer类型或者其子类  
            int b = Test.<Integer>add(1, 2.2); //编译错误，指定了Integer，不能为Float  
            Number c = Test.<Number>add(1, 2.2); //指定为Number，所以可以为Integer和Float  
        }  
    
        //这是一个简单的泛型方法  
        public static <T> T add(T x,T y){
          
            return y;  
        }  
    }

其实在泛型类中，不指定泛型的时候，也差不多，只不过这个时候的泛型为Object，就比如ArrayList中，如果不指定泛型，那么这个ArrayList可以存储任意的对象。

*  Object泛型

public static void main(String[] args) {
          
        ArrayList list = new ArrayList();  
        list.add(1);  
        list.add("121");  
        list.add(new Date());  
    }

[58c8f6b19262478cb5e4701649028769.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/c167f5b80b5848b08239c92319fd28cb.png
[f4f009e854f74bd19d7d42619c09948d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/bda4d44cd37b418ea524701c0a0e4f68.png
[49bdf701f1fb4635944c471fba375044.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/5392d59dafcb4c4eb092d094a1393413.png