Java中泛型的深入理解

野性酷女 2023-09-24 12:33 143阅读 0赞

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

*  泛型深入
 *   *  泛型基本介绍
     *  自定义泛型类
     *  自定义泛型方法
     *  自定义泛型接口
     *  泛型通配符和上下限

## 泛型深入 ##

### 泛型基本介绍 ###

**泛型的概述**:

> 泛型：是JDK5中引入的特性，可以在编译阶段约束操作的数据类型，并进行检查。
> 
> 泛型的格式：`<数据类型>;` 注意：泛型只能支持引用数据类型。
> 
> 集合体系的全部接口和实现类都是支持泛型的使用的。

**泛型的好处**:

> 统一数据类型。
> 
> 把运行时期的问 题提前到了编译期间，避免了强制类型转换可能出现的异常，因为编译阶段类型就能确定下来。

**泛型可以在很多地方进行定义**:

> 定义在类后面 —> 泛型类
> 
> 定义在方法上 —> 泛型方法
> 
> 定义在接口后面 —> 泛型接口

**如果需要存任意类型的数据, 我们可以不添加泛型或者规定泛型为Object(*推荐使用泛型更加规范*)**:

public static void main(String[] args) {
        
        List<Object> list = new ArrayList<>();
        list.add("aaa");
        list.add(123);
        list.add(12.34);
        list.add(false);
    }

**注意: 泛型必须是引用类型, 基础类型需要使用包装类**

public static void main(String[] args) {
        
        // 例如int类型需要使用Integer包装类
        List<Integer> lists = new ArrayList<>();
        lists.add(123);
    }

### 自定义泛型类 ###

**泛型类的概述**:

> 定义类时同时定义了泛型的类就是泛型类。
> 
> 泛型类的格式：`修饰符 class 类名<泛型变量> { }`

例如：`public class MyArrayList<T> { }`

> 此处泛型变量 T 可以随便写为任意标识，常见的如E、T、K、V等。
> 
> 作用：编译阶段可以指定数据类型，类似于集合的作用。

**用下面的案例来举例**:

> 模拟ArrayList集合自定义一个集合MyArrayList集合, 模拟添加和删除功能的泛型设计。

*  定义一个泛型类

public class MyArrayList<E> {
        
        public void add(E a) {
        
            System.out.println(a);
        }
    
        public void remove(E b) {
        
            System.out.println(b);
        }
    }

*  测试使用泛型类

public static void main(String[] args) {
        
        // 规定泛型
        MyArrayList<String> list = new MyArrayList<>();
        // 规定了泛型后, 只能使用规定的类型
        list.add("aaa"); // aaa
        list.remove("bbb"); // bbb
    }

**泛型类的原理**:

> 把出现泛型变量(*E、T、K、V*)的地方全部替换成传输的真实数据类型, 做到约束数据类型的作用。

### 自定义泛型方法 ###

**泛型方法的概述**:

> 定义方法时同时定义了泛型的方法就是泛型方法。
> 
> 泛型方法的格式：`修饰符 <泛型变量> 方法返回值 方法名称(形参列表) {}`

例如:`public <T> void show(T t) {}`

> 作用：让方法中可以使用泛型接收一切实际类型的参数，使方法更具备通用性。

**用下面一个例子进行讲解**:

> 给你任何一个类型的数组，都能返回它的内容。也就是实现Arrays.toString(数组)的功能！

*  定义一个接收任意类型数组的泛型方法

// 定义泛型方法
    public static <T> void printArray(T[] arr) {
        
        StringBuilder stb = new StringBuilder("[");
        for (int i = 0; i < arr.length; i++) {
        
            stb.append(arr[i]).append(i == arr.length - 1 ? "": ", ");
        }
        stb.append("]");
        System.out.println(stb);
    }

*  测试: 使用泛型方法

public static void main(String[] args) {
        
        Integer[] arr1 = {
        10, 20, 30};
        printArray(arr1); // [10, 20, 30]
    
        String[] arr2 = {
        "aaa", "bbb", "ccc"};
        printArray(arr2); // [aaa, bbb, ccc]
    }

**泛型方法的原理**:

> 把出现泛型变量的地方全部替换成传输的真实数据类型。

### 自定义泛型接口 ###

**泛型接口的概述**:

> 使用了泛型定义的接口就是泛型接口。
> 
> 泛型接口的格式：`修饰符 interface 接口名称<泛型变量>{}`

例如: `public interface Data<E>{}`

> 作用：泛型接口可以让**实现类**选择当前功能需要操作的数据类型

**我们还是通过一个例子讲解**:

> 需求: 教务系统，提供一个接口可约束一定要完成数据（学生，老师）的增删改查操作

*  由于在接口中方法的类型定义为学生类型和老师类型都是不合适的, 所以需要使用泛型, 创建一个泛型接口

public interface Date<E> {
        
        void add(E e);
        void delete(E e);
        void update(E e);
    }

*  再在创建实现类时, 传入真实的类型即可, 类似如下:

class Teacher {
        
    
    }
    
    class TeacherData implements Date<Teacher> {
        
        @Override
        public void add(Teacher teacher) {
        
    
        }
    
        @Override
        public void delete(Teacher teacher) {
        
    
        }
    
        @Override
        public void update(Teacher teacher) {
        
    
        }
    }

**泛型接口的原理**:

> 实现类可以在实现接口的时候传入自己操作的数据类型，这样重写的方法都将是针对于该类型的操作。

### 泛型通配符和上下限 ###

**通配符: `?`**

> `?` 可以在“使用泛型”的时候代表一切类型。
> 
> E T K V 是在定义泛型的时候使用的。

**演示代码**:

// 表示接收任意类型的列表
    public static void go(ArrayList<?> list) {
        
    
    }

**泛型的上下限, 格式如下**:

> `? extends Car`: 表示 ? 必须是Car或者其子类 泛型上限

// 传入的类型必须是Car或者Car的子类
    public static void go(ArrayList<? extends Car> list) {
        
    
    }

> `? super Car` ： 表示 ? 必须是Car或者其父类 泛型下限(*了解*)

// 传入的类型必须是Car或者Car的父类
    public static void go(ArrayList<? super Car> list) {
        
    
    }