泛型进阶-Java

﹏ヽ暗。殇╰゛Y 2024-02-21 11:44 79阅读 0赞

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

*  一、泛型的定义和引出
 *   *  1.1 定义
     *  1.2 引出泛型
 *  二、泛型类使用
 *   *  2.1 语法
     *  2.2 示例
     *  2.3 类型推导
     *  三、裸类型（了解）
 *  四、泛型编译原理
 *   *  4.1 擦除机制
     *  4.2 为什么不能实例化泛型类数组
 *  五、泛型上界
 *   *  5.1 语法
     *  5.2 示例
     *  5.3 复杂示例
 *  六、泛型方法
 *   *  6.1 定义语法
     *  6.2 示例
     *  6.3 使用实例-可以类型推导
     *  6.4 使用实例-不可以类型推导
 *  七、通配符
 *   *  7.1 通配符解决什么问题
     *  7.2 通配符上界
     *  7.3 通配符下界

## 一、泛型的定义和引出 ##

### 1.1 定义 ###

一般的类和方法，只能使用具体的类型: 要么是基本类型，要么是自定义的类。如果要编写可以应用于多种类型的代码，这种刻板的限制对代码的束缚就会很大，泛型是在JDK1.5引入的新的语法，通俗讲，**泛型：就是适用于许多许多类型**。从代码上讲，就是**对类型实现参数化**。

### 1.2 引出泛型 ###

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

1.  以前用的数组，只能存放指定类型的元素，例如：int\[\] array = new int\[10\]; String\[\] strs = new String\[10\];
2.  所有类的父类，默认为Object类。数组是否可以创建为Object？

class MyArray {
        
       public Object[] array = new Object[10];
       public Object getPos(int pos) {
        
          return this.array[pos];
       }
       public void setVal(int pos,Object val) {
        
          this.array[pos] = val;
       }
    }
    public class Test{
        
       public static void main(String[] args) {
        
          MyArray myArray = new MyArray();
          myArray.setVal(0,10);
          myArray.setVal(1,"hello");//字符串也可以存放
          String ret = myArray.getPos(1);//编译报错
          System.out.println(ret);
       }
    }

以上代码实现后发现：

1.  任何类型数据都可以存放
2.  1号下标本身就是字符串，但编译报错，必须进行强制类型转换  
    在这种情况下，当前数组任何数据都可以存放，但更多情况下，还是希望它只能够持有一种数据类型，而不是同时持有许多类型。所以，**泛型的主要目的：就是指定当前的容器，要持有什么类型的对象**。**让编译器去做检查**。此时就需要把类型作为参数传递，需要什么类型，就传什么类型。  
    语法：

class 泛型类名称<类型形参列表> {
        
       // 这里可以使用类型参数
    }
    class ClassName<T1, T2, ..., Tn> {
        
    
    }

class 泛型类名称<类型形参列表> extends 继承类/* 这里可以使用类型参数 */ {
        
       // 这里可以使用类型参数
    }
    class ClassName<T1, T2, ..., Tn> extends ParentClass<T1> {
        
       // 可以只使用部分类型参数
    }

对上述代码进行改写：

class MyArray<T> {
        
       public T[] array = (T[])new Object[10];//1
       public T getPos(int pos) {
        
          return this.array[pos];
       }
       public void setVal(int pos,T val) {
        
          this.array[pos] = val;
       }
    }
    public class TestDemo {
        
       public static void main(String[] args) {
        
    		MyArray<Integer> myArray = new MyArray<>();
            myArray.setVal(0,10);
            myArray.setVal(1,9);
            int ret = myArray.getPos(0);//10
            System.out.println(ret);
            //myArray.setVal(3,"hello");编译报错
       }
    }

解释：

1.  类名后的 代表占位符，表示当前类是一个泛型类规范 。类型形参一般使用一个大写字母表示，常用的名称有  
    ![在这里插入图片描述][fdc2085d18b2447ea65a3b7c0a281ec7.png_pic_center]
2.  不能new泛型类型的数组

> T\[\] ts = new T\[5\];//编译报错

1.  在使用泛型类型时加入 指定当前元素类型
2.  编译器会在存放元素时进行类型检查，若不是要存放类型，会编译报错

## 二、泛型类使用 ##

### 2.1 语法 ###

> 泛型类<类型实参> 变量名; // 定义一个泛型类引用  
> new 泛型类<类型实参>(构造方法实参); // 实例化一个泛型类对象

### 2.2 示例 ###

> MyArray list = new MyArray();

泛型只能接受类，所有的基本数据类型必须使用包装类

### 2.3 类型推导 ###

编译器可以根据上下文推导出类型实参，可以省略类型实参的填写

> MyArray list = new MyArray<>(); // 推导出实例化的类型实参为 Integer

总结:

1.  泛型是将数据类型参数化，进行传递
2.  使用 表示当前类是一个泛型类。
3.  泛型目前为止的优点：数据类型参数化，编译时自动进行类型检查和转换

### 三、裸类型（了解） ###

裸类型是一个泛型类但没有带着类型实参，例如

> MyArray list = new MyArray();//MyArrayList 就是一个裸类型

**不要自己去使用裸类型，裸类型是为了兼容老版本的 API 保留的机制**

## 四、泛型编译原理 ##

### 4.1 擦除机制 ###

泛型到底是怎么编译的？  
通过命令：javap -c 查看字节码文件，所有的T都是Object  
![在这里插入图片描述][a0e357d84f1b46cd91be77bac7d90be7.png_pic_center]  
**擦除机制**:在编译的过程当中，将所有的T替换为Object。  
Java的泛型机制在编译级别实现。**编译器生成的字节码在运行期间并不包含泛型的类型信息**。  
提出问题：  
1、那为什么，T\[\] ts = new T\[5\]; 不对，编译时替换为Object，不是相当于：Object\[\] ts = new  
Object\[5\]吗？  
2、类型擦除，一定是把T变成Object吗？

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

class MyArray<T> {
        
    	public T[] array = (T[])new Object[10];
    
        public T getPos(int pos){
        
            return this.array[pos];
        }
        public void  setVal(int pos,T val){
        
            array[pos] = val;
        }
    
        public T[] getArray() {
        
            return array;
        }
    }
    public static void main(String[] args) {
        
         MyArray<Integer> myArray = new MyArray<>();
         Integer[] arr = myArray.getArray();
    }

运行时报错：  
![在这里插入图片描述][435cabd7a68d42dd84bcde51af363016.png_pic_center]  
原因：替换后的方法为：将Object\[\]分配给Integer\[\]引用

public Object[] getArray() {
        
       return array;
    }

通俗讲就是：**返回的Object数组里，可能存放的是任何数据类型，可能是String，可能是Person，运行时直接转给Integer类型数组，编译器认为是不安全的**。  
正确方式（了解）：

public class MyArray<T> {
        
        public T[] array;
        public MyArray(){
        
    
        }
    
        /**
         * 使用反射创建指定类型数组
         * @param tclass
         * @param capacity
         */
        public MyArray(Class<T> tclass,int capacity){
        
            array = (T[]) Array.newInstance(tclass,capacity);
        }
    
        public T getPos(int pos){
        
            return this.array[pos];
        }
        public void  setVal(int pos,T val){
        
            array[pos] = val;
        }
    
        public T[] getArray() {
        
            return array;
        }
    
        public static void main(String[] args) {
        
            MyArray<Integer> myArray = new MyArray<>();
            Integer[] arr = myArray.getArray();
        }
    }

## 五、泛型上界 ##

在定义泛型类时，有时需要**对传入的类型变量做一定约束**，可以通过类型边界来约束。

### 5.1 语法 ###

class 泛型类名称<类型形参 extends 类型边界> {
        
    	...
    }

### 5.2 示例 ###

public class MyArray<E extends Number> {
        
        ...
    }

只接受 Number 的子类型作为 E 的类型实参

MyArray<Integer> list1; // 正常， Integer 是 Number 的子类型
    MyArray<String> list2; // 编译错误，String 不是 Number 的子类型

**没有指定类型边界 E，可以视为 E extends Object**

### 5.3 复杂示例 ###

public class MyArray<E extends Comparable<E>> {
        
       ...
    }

**E必须实现Comparable接口**

## 六、泛型方法 ##

### 6.1 定义语法 ###

方法限定符 <类型形参列表> 返回值类型 方法名称(形参列表){
        
        ...
    }

### 6.2 示例 ###

public class FuncText {
        
    	//静态的泛型方法 需要在static后用<>声明泛型类型参数
    	public static <E> void swap(E[] array, int i, int j) {
        
    		E t = array[i];
    		array[i] = array[j];
    		array[j] = t;
    	}
    }

### 6.3 使用实例-可以类型推导 ###

Integer[] a = {
         ... };
    	swap(a, 0, 9);
    	
    	String[] b = {
         ... };
    	swap(b, 0, 9);

### 6.4 使用实例-不可以类型推导 ###

Integer[] a = {
         ... };
    	FuncText.<Integer>swap(a, 0, 9);
    
    	String[] b = {
         ... };
    	FuncText.<String>swap(b, 0, 9);

## 七、通配符 ##

**? 用于在泛型的使用，即为通配符**

### 7.1 通配符解决什么问题 ###

解决可以接收所有泛型类型，但又不让用户随意更改的问题

class Message<T> {
        
    	private T message ;
    	public T getMessage() {
        
    		return message;
    	}
    	public void setMessage(T message) {
        
    		this.message = message;
    	}
    }
    public class Test{
        
    	public static void main(String[] args) {
        
    		Message<String> message = new Message<>() ;
    		message.setMessage("hello world");
    		fun(message);
    	}
    	public static void fun(Message<String> temp){
        
    		System.out.println(temp.getMessage());
    	}
    }

以上程序会带来新的问题，如果现在泛型的类型设置的不是String，而是Integer

public class Test {
        
    	public static void main(String[] args) {
        
    		Message<Integer> message = new Message() ;
    		message.setMessage(99);
    		fun(message); // 出现错误，只能接收String
    	}
    	public static void fun(Message<String> temp){
        
    		System.out.println(temp.getMessage());
    	}
    }

需要的解决方案：**可以接收所有的泛型类型**，但又**不能让用户随意修改**,这种情况就需要\*\*使用通配符"?"\*\*来处理。

public class TestDemo {
        
    	public static void main(String[] args) {
        
    		Message<Integer> message = new Message() ;
    		message.setMessage(55);
    		fun(message);
    	}
    	// 使用通配符"?"描述它可以接收任意类型，但由于不确定类型，所以无法修改
    	public static void fun(Message<?> temp){
        
    		//temp.setMessage(100); 无法修改！
    		System.out.println(temp.getMessage());
    	}
    }

在"?"的基础上又产生了两个子通配符：  
![在这里插入图片描述][3897e30469d5461a9026013711a99ee9.png]

### 7.2 通配符上界 ###

语法：

<? extends 上界>
    <? extends Number>//可以传入实参类型是Number或者Number的子类

class Food {
        
    
    }
    class Fruit extends Food {
        
    
    }
    class Apple extends Fruit {
        
    
    }
    class Banana extends Fruit {
        
    
    }
    class Message<T> {
         // 设置泛型
        private T message ;
        public T getMessage() {
        
            return message;
        }
        public void setMessage(T message) {
        
            this.message = message;
        }
    }
    public class Text {
        
        public static void main(String[] args) {
        
            Message<Banana> message = new Message<>() ;
            message.setMessage(new Banana());
            fun(message);
        }
        // 此时使用通配符"?"描述的是它可以接收任意类型，但是由于不确定子类类型，所以无法修改
        public static void fun(Message<? extends Fruit> temp){
        
            //temp.setMessage(new Banana()); //仍然无法修改
            Fruit fruit = temp.getMessage();//可以接收读取的数据
            System.out.println(fruit);
        }
    }

此时无法在fun函数中对temp进行添加元素，因为**temp接收的是Fruit和他的子类，此时存储的元素应该是哪个子类无法确定，所以添加会报错，但是可以获取元素**。  
通配符的上界，不能写入数据，只能(接收)读取数据。

### 7.3 通配符下界 ###

**语法**：

<? super 下界>
    <? super Integer>//代表 可以传入实参的类型是Integer或者Integer的父类类型

class Food {
        
    
    }
    class Fruit extends Food {
        
    
    }
    class Apple extends Fruit {
        
    
    }
    class Banana extends Fruit {
        
    
    }
    class Plate<T> {
        
        private T plate ;
        public T getPlate() {
        
            return plate;
        }
        public void setPlate(T plate) {
        
            this.plate = plate;
        }
    }
    public class Text {
        
        public static void main(String[] args) {
        
            Plate<Fruit> plate1 = new Plate<>();
            plate1.setPlate(new Apple());
            func(plate1);
    
        }
        public static void func(Plate<? super Fruit> tmp){
        
            // 此时可以修改，添加Fruit 或者Fruit的子类
            tmp.setPlate(new Apple());//添加Fruit的子类
            tmp.setPlate(new Fruit());//添加Fruit类
            //Fruit fruit = tmp.getPlate();不能接收，无法确定是哪个父类
            System.out.println(tmp.getPlate());//只能直接输出
        }
    }

通配符的下界，不能接收读取的数据，只能写入数据。

[fdc2085d18b2447ea65a3b7c0a281ec7.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/21/56810d5c6cd3476a8e0925dcb4c8cc24.png
[a0e357d84f1b46cd91be77bac7d90be7.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/21/00647657bda84b05833319b0d03adb45.png
[435cabd7a68d42dd84bcde51af363016.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/21/5f203d4f27c04ad1bc52266afe37a9d8.png
[3897e30469d5461a9026013711a99ee9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/21/f13c95bdc43a460c89aab2511b61aa2c.png