【JAVA】泛型

【JAVA】泛型
泛型
补充

你一定可以成为你想要成为的人！！

学习学习！！

一、什么是泛型
1. 一般的类和方法，只能使用具体的类型: 要么是基本类型，要么是自定义的类。如果要编写可以应用于多种类型的代码，这种刻板的限制对代码的束缚就会很大。----- 来源《Java编程思想》对泛型的介绍。
2. 泛型是在JDK1.5引入的新的语法，通俗讲，泛型：就是适用于许多许多类型。从代码上讲，就是对类型实现了参数化。
3. 即：类型作为参数进行传入
二、引入泛型
1. 实现一个类，类中包含一个数组成员，使得数组中可以存放任何类型的数据，也可以根据成员方法返回数组中某个下标的值？
- 思路：
  1、我们以前学过的数组，只能存放指定类型的元素，例如：int[] array = new int[10]; String[] strs = new String[10];
  2、所有类的父类，默认为Object类。数组是否可以创建为Object?
√ 数组创建为Object类型可以放任意类型的数据！
但是在返回时可能会需要强转–当所写返回值类型与实际位置返回值类型不一致时强转为实际类型
1. 在数组创建为Object类型的情况下，当前数组任何数据都可以存放；但是，更多情况下，我们还是希望他只能够持有一种数据类型，而不是同时持有这么多类型。
2. 所以，泛型的主要目的：就是指定当前的容器要持有什么类型的对象。让编译
  器去做检查。此时，就需要把类型作为参数传递。需要什么类型，就传入什么类型。
1. 语法
1. 语法格式：
```
class 泛型类名称<类型形参列表> { 
// 这里可以使用类型参数
 }
class ClassName<T1, T2, ..., Tn> { 
}
1
2
3
4
5
```
```
class 泛型类名称<类型形参列表> extends 继承类/* 这里可以使用类型参数 */ { 
// 这里可以使用类型参数 
}
class ClassName<T1, T2, ..., Tn> extends ParentClass<T1> { 
// 可以只使用部分类型参数 
}
1
2
3
4
5
6
```
1. 注意事项：
- <>中如果指定了类型，说明此时这个类里面只能放该类型的数据
- <>中是包装类！
- 指定类型可以有多个，用逗号（，）进行分隔开
1. 具体举例：
```
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<>();//2
    myArray.setVal(0,10);
    myArray.setVal(1,12); 
    int ret = myArray.getPos(1);//3 
    System.out.println(ret);
    myArray.setVal(2,"bit");//4 
  } 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
```
1. 补充
  1、类名后的代表占位符，表示当前类是一个泛型类
  2、了解：【规范】类型形参一般使用一个大写字母表示，常用的名称有：
E 表示 Element
K 表示 Key
V 表示 Value
N 表示 Number
T 表示 Type
S, U, V 等等 - 第二、第三、第四个类型

3、注释1处，不能new泛型类型的数组
- public T[] array = (T[])new Object[10]; // 是new Object类型的数组，再强转为泛型类型的数组。
- 即：T[] ts = new T[5];//是不对的
  4、注释2处，类型后加入指定当前类型
  MyArray myArray = new MyArray<>();//即：类型要写为包装类
  5、注释3处，不需要进行强制类型转换
  int ret = myArray.getPos(1); // 因为在进行申明时传入的参数类型就是int类型
  6、注释4处，代码编译报错，此时因为在注释2处指定类当前的类型，此时在注释4处，编译器会在存放元素的时候帮助我们进行类型检查。
  myArray.setVal(2,“bit”); // 已经指定类型为int型，则传入String类型就会编译错误。
1. 泛型的主要目的：就是指定当前的容器，要持有什么类型的对象让编译器去做检查。
2. 补充

1、尖括号里面的类型是指定了元素的特定类型
2、当指定类型之后，编译器会根据所指定的类型参数进行
类型的检查
3、尖括号中指定类型之后，当取元素的时候就不需要进行
强制类型转换了
4、泛型的尖括号中是引用类型，而不是基本类型

 三、泛型类的使用

 1. 语法
```
泛型类<类型实参> 变量名; // 定义一个泛型类引用 
new 泛型类<类型实参>(构造方法实参); // 实例化一个泛型类对象
1
2
```
new时的类型实参是可以省略的，但是前面的不能省略，此时根据前面的可以推导出后面的类型

 2. 举例
```
MyArray<Integer> list = new MyArray<Integer>();
1
```
注意：泛型只能接受类，所有的基本数据类型必须使用包装类！

3. 类型推导(Type Inference)

当编译器可以根据上下文推导出类型实参时，可以省略类型实参的填写。
```
MyArray<Integer> list = new MyArray<>(); // 可以推导出实例化需要的类型实参为Integer
1
```
四、裸类型(Raw Type) （了解）
1. 裸类型是一个泛型类但没有带着类型实参，例如：MyArrayList 就是一个裸类型。
```
MyArray list = new MyArray();
1
```
1. 不带类型实参进行实例化时，相当于Object类型，可以存放任意类型的元素
2. 注意：我们不要自己去使用裸类型，裸类型是为了兼容老版本的 API 保留的机制
3. 【小结】
1. 泛型是将数据类型参数化，进行传递
2. 使用 < T> 表示当前类是一个泛型类。
3. 泛型目前为止的优点：数据类型参数化，编译时自动进行类型检查和转换
五、泛型如何编译的

 1. 擦除机制
1. 通过命令：javap -c （反编译：其实也可以在IDEA上直接进行下载安装）查看字节码文件，所有的T都是Object。
2. 编译好的字节码文件，T类型参数都变成了Object类型！！
3. 在编译的过程当中，将所有的T替换为Object这种机制，我们称为：擦除机制。
4. Java的泛型机制是在编译级别实现的。编译器生成的字节码在运行期间并不包含泛型的类型信息。
5. *擦除机制：把泛型T在编译的时候擦除为Object
  擦除机制是编译时期的一种机制，在运行时是没有泛型的概念的
2. 为什么不能实例化泛型类型数组
1. public T[] array = (T[])new Object[10];
  // 不能直接new一个Object类型的数组，因为Object类型的数组可以存放任意类型的元素，不全是T类型的，所以需要进行强转
2. 数组和泛型之间的一个重要区别是它们如何强制执行类型检查。具体来说，数组在运行时存储和检查类型信息。然而，泛型在编译时检查类型错误。
  （即：数组运行泛型编译检查类型错误）
3. 正确方式
  （看注释的三个方法）
```
class MyArray<T> {
  public T[] array;   // 1. 不去new一个数组
  public MyArray() { 
  }
  
  /**
  * 通过反射创建，指定类型的数组
  * @param clazz
  * @param capacity
  */
  public MyArray(Class<T> clazz, int capacity) { 
  // 2. 通过该方法传(一个类型，capacity（容量）)，然后强转为T[]
    array = (T[])Array.newInstance(clazz, capacity); 
  }
  public T getPos(int pos) { 
    return this.array[pos]; 
  }
  public void setVal(int pos,T val) { 
    this.array[pos] = val; 
  }
  public T[] getArray() { 
    return array; 
  } 
}

public static void main(String[] args) { 
// 3. new之后进行传参，类型参数是包装类.class
  MyArray<Integer> myArray1 = new MyArray<>(Integer.class,10); 
  Integer[] integers = myArray1.getArray(); 
}
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
29
30
```
六、泛型的上界
- 只有泛型的上界，没有泛型的下界。
- 在定义泛型类时，有时需要对传入的类型变量做一定的约束，可以通过类型边界来约束。
1. 语法
```
class 泛型类名称<类型形参 extends 类型边界> {
...
}
1
2
3
```
如果没有上界，编译时将会默认擦除为Object，但是有了上界，将会被擦除成为所指定的类型。

2. 示例
```
public class MyArray<E extends Number> {
// 代表能传入的是Number及其子类
...
}
1
2
3
4
```
- 举个例子：
```
MyArray<Integer> l1; // 正常，因为 Integer 是 Number 的子类型 
MyArray<String> l2; // 编译错误，因为 String 不是 Number 的子类型
1
2
```
3. 复杂示例-泛型类找最大值

写一个泛型类，找出数组中的最大值。
- 自定义/引用类型不可以直接比较大小，要使用比较器
- 所以：类型参数T要继承Comparable接口，实现了该接口就可以进行大小比较了
  如：class Alg {… .compareTo()与0进行大小比较}
- 代码
```
package maxvalue;

// 写一个泛型类，找出数组中的最大值。


import java.util.Scanner;

// 泛型类需要进行比较
// 泛型类是引用类型，比较大小需要比较器

class Alg<T extends Comparable<T>> { // 实现接口

    // 返回尖括号中的类型
    public T findMaxValue(T[] array) {
        T max = array[0]; // 类型要对应！
        for (int i = 0; i < array.length; i++) {
            // 引用类型使用compareTo比较大小,需要比较器Comparable,然后既可以直接适用compareTo方法进行大小比较
            if(array[i].compareTo(max) >0) {
                max = array[i];
            }
        }
        return max;
    }
}

// ；模拟静态方法不依赖于对象
//class Alg1> { //静态方法不依赖于对象，所以根本不需要传入尖括号中的类
class Alg1 {
    public static<T extends Comparable<T>> T findmaxValue(T[] array) {  // 然后在static后面加尖括号进行类型以及边界的指定
        T max = array[0]; // 类型要对应！
        for (int i = 0; i < array.length; i++) {
            // 引用类型使用compareTo比较大小,需要比较器Comparable
            if(array[i].compareTo(max) >0) {
                max = array[i];
            }
        }
        return max;
    }
}

public class MaxValue {

    public static void main(String[] args) {
        // 进行实例化时不要忘记尖括号中的类型参数
       Alg<Integer> alg = new Alg<>();
       // 给定要进行比较的类型数组
        Integer[] array = {1,3,5,7,8,3,6,82};
        
        // 注意返回值类型
        System.out.println("依赖对象的泛型：");
        int maxValue = alg.findMaxValue(array);
        System.out.println(maxValue);

        // 以上注意到依赖对象 如果不想要依赖于对象，则使用静态方法：如类Alg1
        System.out.println("不依赖对象的泛型：");
        System.out.println(Alg1.findmaxValue(array));
    }
}
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
```
七、泛型方法

 1. 语法
```
方法限定符 <类型形参列表> 返回值类型 方法名称(形参列表) { ... }
1
```
2. 示例
```
public class Util { 
  //静态的泛型方法 需要在static后用<>声明泛型类型参数
  public static <E> void swap(E[] array, int i, int j) {
    E t = array[i]; 
    array[i] = array[j]; 
    array[j] = t; 
  } 
}
1
2
3
4
5
6
7
8
```
3. 使用示例-可以类型推导
```
Integer[] a = { ... }; 
swap(a, 0, 9); 
String[] b = { ... }; 
swap(b, 0, 9);
1
2
3
4
```
4. 使用示例-不使用类型推导
```
Integer[] a = { ... }; 
Util.<Integer>swap(a, 0, 9);  // 注意区别使用类型推导的示例！
String[] b = { ... }; 
Util.<String>swap(b, 0, 9);
1
2
3
4
```
5. 小结
1. 不依赖于对象，如果直接使用类名进行方法调用，则：
  class Alg（Alg处为可以进行替换的类名） {
  public static> T findMaxValue(T[] array) {
  …
  内部使用compareTo方法进行大小比较
  }
  }
  调用若使用静态方法调用： int val = Alg.< Integer>findMaxValue(array);
  // 此时< Integer>可以省略，由传入的实参进行推测类型
2. 泛型方法有静态方法和成员方法：由static进行区别！
八、通配符
- ? 用于在泛型的使用，即为通配符
1. 通配符解决什么问题
1. 通配符是用来解决泛型无法协变的问题的，协变指的就是如果 Student 是 Person 的子类，那么 List< Student> 也应该是 List< Person> 的子类。但是泛型是不支持这样的父子类关系的。
2. 泛型 T 是确定的类型，一旦你传了我就定下来了，而通配符则更为灵活或者说是不确定，更多的是用于扩充参数的范围。
3. 可以接收所有的泛型类型，但是又不能够让用户随意修改。这种情况就需要使用通配符"?"来处理。
4. 通配符示例：
```
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()); } 
}
1
2
3
4
5
6
7
8
9
10
11
```
1. 小结：
- 尖括号中的内容不参与类型的组成，但是参与类型的检查
- 想什么类型都匹配就在尖括号中给出？通配符
- 通配符：不管什么类型都可以接收
- 把类型参数变为通配符？后，不可以再使用之前的写有具体参数类型的方法进行传入参数了，因为通配符可以接收任意类型的数据，并不一定是之前写好的类型，即类型不确定
1. 在"?"的基础上又产生了两个子通配符
? extends 类：设置泛型上限
? super 类：设置泛型下限
1. 泛型只有上界extends 没有下界
  通配符？既有上界extends，又有下界super
2. 通配符上界
1. 语法
  *传入的是上界类型及其子类！！
```
<? extends 上界> 
// 实例：
<? extends Number>//可以传入的实参类型是Number或者Number的子类
1
2
3
```
1. 示例：
```
// 此时使用通配符"?"描述的是它可以接收任意类型，但是由于不确定类型，所以无法修改
public static void fun(Message<? extends Fruit> temp){ 

// 无法确定temp引用的是哪个子类对象，所以无法进行修改new

  //temp.setMessage(new Banana()); //仍然无法修改！ 
  //temp.setMessage(new Apple()); //仍然无法修改！ 
  
//放的都是Fruit的子类，所以可以直接用Fruit进行接收
// 相当于：Fruit b = temp.getMessage();

  System.out.println(temp.getMessage()); // 可以进行信息获取
}
1
2
3
4
5
6
7
8
9
10
11
12
13
```
1. 【小结】：
  so：
  一般而言，通配符的上界是用来读数据的，而不是修改数据，也不能用具体的子类进行接收。
3. 通配符下界
1. 语法
  *传入下界类型及其父类
```
<? super 下界> 
// 具体举例
<? super Integer>//代表 可以传入的实参的类型是Integer或者Integer的父类类型
1
2
3
```
1. 示例：
```
//temp 接收Fruit及其子类的一个Message
public static void fun(Message<? super Fruit> temp){ 
// 此时可以修改！！添加的是Fruit 或者Fruit的子类 
  temp.setMessage(new Apple()); //这个是Fruit的子类 
  temp.setMessage(new Fruit());//这个是Fruit的本身 
  //Fruit fruit = temp.getMessage(); 不能接收，这里无法确定是哪个父类 
  System.out.println(temp.getMessage());//只能直接输出
}
1
2
3
4
5
6
7
8
```
1. 【小结】：
- 通配符的下界，不能进行读取数据，只能写入数据。
- 通配符的下界一般用来添加元素，获取的元素不能用具体的类型进行接收（因为无法确定具体是那个父类）。
九、包装类

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

1. 基本数据类型和对应的包装类

注：除了 Integer 和 Character，其余基本类型的包装类都是首字母大写。

2. 装箱和拆箱
1. 装箱和拆箱又称为装包和拆包。
- 装箱：即基本类型数据放到包装类中。装箱：基本数据类型->包装类型
- 拆箱：即包装类值放到基本数据类型中
```
int i = 10; 
// 装箱操作，新建一个 Integer 类型对象，将 i 的值放入对象的某个属性中 
Integer ii = Integer.valueOf(i); 
Integer ij = new Integer(i); 
// 拆箱操作，将 Integer 对象中的值取出，放到一个基本数据类型中 
int j = ii.intValue();
1
2
3
4
5
6
```
1. 小结装箱的三种方式：
- Integer integer = i; //自动装箱：但是底层调用的依旧是Integer.valueOf();
- 显示装箱：Integer ii = Integer.valueOf(i);
  Integer ij = new Integer(i);
1. 小结拆箱方式：
- 拆箱：显示拆箱
  int val = interger; //自动拆箱
- // 手动拆箱：根据不同类型使用不同的Value
  int value = interger.intValue();
  double value2 = integer.doubleValue();
3. 自动装箱和拆箱

可以看到在使用过程中，装箱和拆箱带来不少的代码量，所以为了减少开发者的负担，java 提供了自动机制。
（其实就类似于：直接赋值与强制类型转换）
```
int i = 10; 
Integer ii = i; // 自动装箱 
Integer ij = (Integer)i; // 自动装箱 
int j = ii; // 自动拆箱 
int k = (int)ii; // 自动拆箱
1
2
3
4
5
```
4. 【面试题】
```
public static void main(String[] args) { 
  Integer a = 127; 
  Integer b = 127; 
  Integer c = 128; 
  Integer d = 128; 
  System.out.println(a == b);  // true
  System.out.println(c == d); // false
}
1
2
3
4
5
6
7
8
```
【分析】abcd都进行了所谓的自动装箱操作。
自动装箱调用的Integer.valueOf()方法，而其范围是：-128~127 （下标是从0开始存储-128，到下标255存储127）
如果超过范围就会new一个新的对象
new新对象就会开辟新的空间。

THINK
1. 泛型尖括号的使用
2. 泛型进行大小比较：引用类型要实现接口并使用compareTo方法比较大小
3. 泛型上界extends（该类型及其子类）
4. 通配符上界extends（该类型及其子类），通配符下界super（该类型及其父类）
5. 装箱以及拆箱：自动以及显示
6. 自动装箱调用Integer.valueOf()方法**，而其范围是：-128~127 ，超出范围就会new一个新的对象。
相关阅读:
如何让WPF中的ValidationRule实现参数绑定
 Elastic Stack 8.10：更简单的跨集群搜索和身份验证等等
 1547_AURIX_TC275_CPU子系统_数据存储接口
 前端必备工具
 而立之年才感悟到的一些箴言(二)
一文解达梦
 Vue 嵌套路由多级路由规则
 c#向c++(opencv)实现base64图像数据传递和编解码
 2022年全球市场氨苯蝶啶原料药总体规模、主要生产商、主要地区、产品和应用细分研究报告
 C++数据结构X篇_16_二叉树的拷贝和释放（采用递归的方法）
原文地址：https://blog.csdn.net/weixin_54150521/article/details/125970553

泛型

补充

一、什么是泛型

二、引入泛型

1. 语法

2. 补充

三、泛型类的使用

1. 语法

2. 举例

3. 类型推导(Type Inference)

四、裸类型(Raw Type) （了解）

五、泛型如何编译的

1. 擦除机制

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

六、泛型的上界

1. 语法

2. 示例

3. 复杂示例-泛型类找最大值

七、泛型方法

1. 语法

2. 示例

3. 使用示例-可以类型推导

4. 使用示例-不使用类型推导

5. 小结

八、通配符

1. 通配符解决什么问题

2. 通配符上界

3. 通配符下界

九、包装类

1. 基本数据类型和对应的包装类

2. 装箱和拆箱

3. 自动装箱和拆箱

4. 【面试题】

THINK