JavaSE之泛型和通配符

JavaSE之泛型和通配符
一、什么是泛型？

一般的类和方法，只能使用具体的类型，要么是基本类型，要么是自定义类型。如果要编写可以应用于多种类型的代码，这种刻板的限制对代码的束缚就会很大。——《Java编程思想》

泛型是JDK1.5引入的新的语法，通俗来说，泛型：就是适用于多种类型，即对类型实现了参数化。Ps：泛型这种机制会在编译时期进行类型的检查和转换。

二、泛型的应用场景

在有些时候，我们可能需要实现一个类，类中有一个数组，我们需要让数组可以存放任意类型的数据。这时候应该如何去做呢？

在不认识泛型的情况下，可能有人会说：那我们把数组定义为Object数组就好了（因为所有类默认都继承于这个类）

但是真的可以吗？我们来看下面代码：

分析：

虽然在这种情况下，当前数组任何数据都能存放，但是，更多情况下，我们还是希望他只能狗持有一种数据类型，而不是同时持有这么多类型，所以，泛型的主要目的：就是指定当前的容器，要持有什么类型的对象。让编译器取做检查。此时，就需要把类型，作为参数传递，需要什么类型，就传入什么类型。

这是我们就需要引入泛型了：

2.1 泛型的语法
```
class 泛型类名称<类型形参列表> {
// 这里可以使用类型参数
}
class ClassName {
}
 
class 泛型类名称<类型形参列表> extends 继承类/* 这里可以使用类型参数 */ {
// 这里可以使用类型参数
}
class ClassName extends ParentClass {
// 可以只使用部分类型参数
}
```
代码实例：

分析：
- 类名后的代表占位符，表示当前类是一个泛型类。
- 类型后加入指定当前类型，这里的类型必须是类类型，不能是基本类型。
- 我们会发现运用泛型：不需要进行强制类型转换。
- 如果存储类型和指定类型不一致，代码编译会报错，这是因为编译器会在存放元素的时候帮助我们进行类型检查。
利用泛型后，我们可以实现类型的参数化：

小结：

泛型存在的最大两个意义：

①存放元素的时候会进行类型的检查

②取出元素的时候，会自动帮你进行类型转换（不需要再进行类型的强转）

泛型主要是编译时期的一种机制（擦除机制），运行时期是没有泛型的概念的。

2.2 泛型类的使用

2.2.1 语法
```
泛型类<类型实参> 变量名; // 定义一个泛型类引用
new 泛型类<类型实参>(构造方法实参); // 实例化一个泛型类对象
```
2.2.2 实例
```
MyArray list = new MyArray();
```
注意泛型只能接受类类型，所有基本数据类型必须使用包装类。

当然这里后面的构造方法实参其实是可以省略不写的：
```
MyArray list = new MyArray<>();
```
2.2.3 裸类型(Raw Type)——了解即可

"裸类型"（raw types）通常是指在使用泛型之前的一种方式，其中集合类或类似的数据结构存储的是Object类型的对象。这种方式是为了与旧版Java代码兼容，但它没有明确指定泛型类型参数。例如 MyArrayList 就是一个裸类型：
```
MyArray list = new MyArray();
```
这是旧版代码，使用裸类型：
```
Box box = new Box(); // 使用裸类型，不指定具体的类型参数
box.set("Hello"); // 存入字符串
String content = (String) box.get(); // 从盒子中获取数据，需要强制类型转换
```
在上面的代码中，Box 类使用裸类型，没有指定类型参数 T，因此在存入数据和取出数据时需要进行强制类型转换。这种做法在旧版的Java中是可以的，但容易引入类型安全问题。

注意：我们不要自己去使用裸类型，裸类型是为了兼容老版本的 API 保留的机制
下面的类型擦除部分，我们也会讲到编译器是如何使用裸类型的。

2.3 擦除机制

通过命令: javap -c 查看字节码文件，所有的T都是Object。

在编译的过程当中，这种讲所有的T都替换为Object这种机制，我们称之为：擦除机制。

注意：Java的泛型机制是在编译期间实现的。编译器生成的字节码在运行期间并不包含泛型的类型信息。

三、泛型的上界

在讲解泛型的上界之前，我们先来思考一个问题：

写一个泛型类，类中有一个方法，求这个数组中的最大值该如何去做？

很显然，这种方式是错误的，因为无法确认传入的类型到底是什么，所以不能利用这种简单粗暴的方式进行比较，那应该如何去做呢？

如果当前数组传入给Asl这个泛型类的类型是Integer这种类型，由于在数组取出的时候会进行自动拆箱（下文会讲解）所以这里不需要重写Compareto方法：

关于Compareto方法的补充：

默认的CompareTo方法是根据对象的自然顺序进行比较的。对于基本数据类型的包装类（如Integer、Double、Character等），默认的CompareTo方法会直接比较它们的数值大小。

对于其他类，如果没有重写CompareTo方法，将会使用默认的比较规则。默认规则是比较对象的内存地址，即比较对象在内存中的存储位置。这意味着，如果两个对象的引用不同，它们被认为是不同的对象，即使它们具有相同的属性值。

如果需要自定义对象的比较规则，可以在类中重写CompareTo方法。在重写方法时，可以根据对象的特定属性来定义比较规则，以确定对象的相对顺序。这样就可以根据需要对对象进行排序或比较。

3.1 语法

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

刚刚上面我们所使用的其实是一种复杂的泛型上界的运用：
```
public class MyArrayextends Comparable> {
...
}
```
其中的 E 必须是实现这个Comparable 接口的类或其子类。比如我们上面传入的Integer：

以下为泛型上界语法：
```
class ClassNameextends UpperBoundType> {
    // ...
}
```
- ClassName是你的泛型类或泛型方法的名称。
- T是泛型类型参数的名称。
- extends关键字用于指定上界。
- UpperBoundType是指定的上界类型，可以是一个类或接口。
- 是哟泛型时，没有指定上界的情况下，在编译时候会由于擦除机制变成Object，如果有上界那么就变成该上界。
需要注意的是：

如果你指定一个类作为上界，那么泛型类型参数必须是该类或其子类。如果你指定一个接口作为上界，那么泛型类型参数必须是实现了该接口的类或其子类。否则将会编译报错。

以下就是自定义类型传入泛型类的情况：
```
class Aslextends Comparable>{
    public T findMax(T[] array) {
        T max = array[0];
        for (int i = 0; i < array.length; i++) {
            if (max.compareTo(array[i]) < 0) {
                max = array[i];
            }
        }
        return max;
    }
}
class Person implements Comparable {
    public int age;
 
    public Person(int age) {
        this.age = age;
    }
 
    @Override
    public int compareTo(Person o) {
        return this.age - o.age;
    }
 
    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                '}';
    }
}
 
public class demo {
    public static void main(String[] args) {
        Asl asl = new Asl<>();
        Person[] people = {new Person(10),new Person(15)};
        Person person = asl.findMax(people);
        System.out.println(person);
    }
}
```
运行结果：

分析：这就需要自定义类型实现Comparable接口了，并且需要重写Compareto方法（没有重写的话就默认比较对象的地址了）。

简单示例：

分析：由于String并不是Number的子类，于是编译器会进行报错。

四、泛型的方法

4.1 泛型静态方法

引入：可能有人会说，每次都需要new一下这个泛型类，太麻烦了，能否用static修饰一下，让其变成类方法？

上图所示的这种方式是不行的，因为由于static修饰的方法不依赖于类对象的创建，所以以上面这种方式，这个泛型的类型是无法确认的，所以报错了。

修改方式如下：
```
class Aslextends Comparable>{
    public staticextends Comparable> T findMax(T[] array) {
        T max = array[0];
        for (int i = 0; i < array.length; i++) {
            if (max.compareTo(array[i]) < 0) {
                max = array[i];
            }
        }
        return max;
    }
}
```
运行代码：

通常会采用下面这种方式，往往这里的实参会忽略不写，Java会根据arr的类型推导出Integer类型。

4.2 泛型方法的另一种写法

五、通配符

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

5.1 通配符解决什么问题？

通配符是主要目的是提高代码的灵活性，以便更容易编写通用的、可复用的代码。

同时也解决了泛型无法协变的原因。（下文泛型的上界会提及）
```
Listextends Number> ln = new ArrayList();
```
泛型 T 是确定的类型，一旦你传了我就定下来了，比如下图，如果是直接使用String的话，那么Integer就无法传入。而通配符则更为灵活或者说是不确定，更多的是用于扩充参数的范围。

观察以下代码：

由于fun方法参数被写死了，所以导致fun方法报错。那么该如何修改呢？

可能有人会说，那么我在写一个fun方法，实现方法的重载不就可以了吗？

其实是不行的，因为其实在编译器角度来看，这两个其实是相同的方法，可以通过以下代码验证：

分析：

可以看到两个类名其实是一样的，代码编译器并不会因为传入的类型不同而将其看出两种不同的参数，所以不能构成方法的重载。

Ps：没有重写toString方法，那么默认的toString方法会返回一个由类名、"@"和对象的哈希码组成的字符串。这个哈希码是通过hashCode（）方法生成的。

引入通配符来解决

运行结果：

需要注意的是：虽然可以利用通配符解决上述问题，但是并不是设置其中的值。

这是因为：在使用？时，由于不确定类型，所以无法修改。

5.2 通配符的上界

通配符也有上界，可以限制传入的类型必须是上界这个类或者是这个类的子类。

语法：
```
extends Number>//可以传入的实参类型是Number或者Number的子类
```
示意图如下：

示例：
```
class Food {
}
class Fruit extends Food {
}
class Apple extends Fruit {
}
class Banana extends Fruit {
}
class Plate { // 设置泛型
    private T plate ;
    public T getPlate() {
        return plate;
    }
    public void setPlate(T plate) {
        this.plate = plate;
    }
}
public class Test3 {
    public static void main(String[] args) {
        Plate plate1 = new Plate<>();
        plate1.setPlate(new Apple());
        fun(plate1);
        Plate plate2 = new Plate<>();
        plate2.setPlate(new Banana());
        fun(plate2);
        
    }
    public static void fun(Plate temp){
        System.out.println(temp.getPlate());
    }
}
```
这里由于通配符的存在，解决了泛型无法协变的原因：Plate plate1可以传递给Plate。

分析：观察以上代码，在使用 ? extends E时，并不知道什么对象符合那个未知的E的子类型，所以无法支持写入，但是由于通配符解决了泛型无法协变的问题，所以这里可以进行接收。但是在方法内部无法进行设置。

另外，虽然无法进行修改，但是可以取里面的数据：

这是因为通配符上界限制了传递进来的参数必须是Fruit或者其子类。

结论：

使用通配符上界可以读取数据，这是因为读取的对象一定是Furit或者是其子类，但是并不适合写入数据，因为不能确定类所持有的对象具体是什么，为了安全，使用通配符上界不能进行写入。

这里的思想跟泛型上界差不多，可以配合理解：

数据存入到Object数组中时，由于Object是所有类的父类，在存入的时候都是可以存的，但是在取出的时候，由于是Object数组，在赋值给String类型数组时候还是需要进行强制类型转换->转换为String类型的值。

5.2 通配符的下界

与泛型不同，通配符可以拥有下界，语法层面上与通配符的上界的区别是把关键字extends改为super。

语法
```
super 下界>
super Integer>  //代表 可以传入的实参的类型是Integer或者Integer的父类类型
```
示例：

分析：由于下界是Fruit，所以只能传递Fruit类或者其父类。如果传递的非这两个，就会编译报错。

结论：

使用通配符下界可以写数据，当然能够写入的数据对象是下界以及下界的子类，但是不能读取数据，因为无法确认取出的数据是什么。

六、包装类

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

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

基本数据类型包装类
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean

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

6.2 装箱和拆箱

装箱（装包）：将基本数据类型变成对应的包装类型。

我们可以查看字节码文件来验证：

拆箱（拆包）：将包装类型转换为基本数据类型。

观察字节码文件可以知道，int b = a 是调用了intValue进行拆箱。

当然我们可以进行显示的拆箱操作：

6.3 关于Integer的经典面试题

观察以下代码，思考运行结果是什么？
```
public class Test6 {
    public static void main(String[] args) {
        Integer a = 100;
        Integer b = 100;
        Integer c = 200;
        Integer d = 200;
        System.out.println(a == b);
        System.out.println(c == d);
    }
}
```
运行结果如下：

为什么呢？

这是因为涉及到了装箱的问题，从上面我们可以得知，Integer a = 10 会进行自动装箱，相当于是调用了valueOf方法，我们来看看valueOf方法的内部实现：

我们可以得知，Integer的值如果是 -128到 127 之间的话

否则会重新new一个对象，当然地址就不一样了。

也就是说如果值在这个范围的话就会返回这里数组中的值，如果是-128那么就返回这个数组的第0项。（-128+（- （- 128）））= 0。
相关阅读:
CAS、AtomicInteger、synchronized原理
 Simplicity Studio 生成的工程移植到 Linux 上编译
 Three.js之模型对象、材质
 LDO线性稳压器要不要并联二极管？
自动化安装脚本（Ansible+shell）
Android修行手册 - TabLayout全解析 - 和ViewPager联动
 php计算机毕业设计基于thinkphp框架的特色旅游网站vue
RMAN备份数据库_重启RMAN备份
 渠道触点归因
 并发编程核心问题 - 可见性,有序性, 原子性
原文地址：https://blog.csdn.net/qq_63218110/article/details/132830852

基本数据类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

一、什么是泛型？

二、泛型的应用场景

2.1 泛型的语法

2.2 泛型类的使用

2.2.1 语法

2.2.2 实例

2.2.3 裸类型(Raw Type)——了解即可

2.3 擦除机制

三、泛型的上界

3.1 语法

四、泛型的方法

4.1 泛型静态方法

4.2 泛型方法的另一种写法

五、通配符

5.1 通配符解决什么问题？

5.2 通配符的上界

5.2 通配符的下界

六、包装类

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

6.2 装箱和拆箱

6.3 关于Integer的经典面试题