目录
[1.1. 基本类型和对应的包装类](#1.1. 基本类型和对应的包装类)
[1.2. 装箱和拆箱](#1.2. 装箱和拆箱)
[1.3. 自动装箱和自动拆箱](#1.3. 自动装箱和自动拆箱)
[3.1. 语法规则](#3.1. 语法规则)
[3.2. 泛型的优点](#3.2. 泛型的优点)
[4.1. 擦除的机制](#4.1. 擦除的机制)
[5.1. 泛型的上界的定义](#5.1. 泛型的上界的定义)
[5.2. 语法规则](#5.2. 语法规则)
[6.1. 定义语法](#6.1. 定义语法)
[6.2. 交换方法的实例](#6.2. 交换方法的实例)
包装类和泛型我们在Java语法中，我们在基本数据类型里面涉及过，但是我们在语法里面用不到，而在数据结构里面我们才会有应用的。
一、包装类
1.1. 基本类型和对应的包装类
Java共有8种基本数据类型，Java给这些基本类型都搞了一个类进行表示，来对这些类进行一个封装，这就是包装类。
|---------|-----------|
| 基本类型 | 包装类 |
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| char | Character |
| boolean | Boolean |
1.2. 装箱和拆箱
在Java当中，提供了一些操作，使包装类和内置类型可以相互转换。内置类型转为包装类型称为装箱，包装类型转为内置类型称为拆箱。但这些代码写法已经过时了，我们需要重点掌握的是⾃动装箱和⾃动拆箱。
1.3. 自动装箱和自动拆箱
java
public class Main {
public static void main(String[] args) {
int i = 10;
Integer ii = i;//自动装箱
Integer ij = (Integer) i;//自动装箱，后面的(Integer)可有可无
int j = ii;//自动拆箱
int k = (int)ii;//自动拆箱，后面的(int)可有可无
}
}我们可以通过javap-c查看字节码⽂件内容，观察装箱和拆箱的操作。我们可以在IDEA里面装一个jclasslib ByteCode Viewer的插件，然后点击View，再点击Show Bytecode With Jclasslib。我们点到main方法，点击code，就可以看到所对应的字节码文件。
我们来看下面的一段代码，此时的a,b,c,d,e都是引用类型变量。当赋值相同时，结果就是true；当赋值不同时，结果就是false。当赋值超出包装类型的范围时，无论赋值相不相等，结果都是false。
这是因为Integer里面的常量值放在常量池当中，我们进行赋值，相当于在常量池中进行取值，如果超出这个值，那么就是池内与池外的进行比较，结果就是false。
java
public class Main {
public static void main(String[] args) {
Integer a = 127;
Integer b = 127;
System.out.println(a == b);//true
Integer c = 128;
Integer d = 128;
System.out.println(c == d);//false
Integer e = 126;
System.out.println(a == e);//false
}
}二、泛型的概念
很多编程语言都有泛型这样的语法机制。在Java中，写一个类或者是方法，需要声明方法里面的成员或者参数的类型。但也有些情况下，需要一个类或者方法能够多种类型支持。也就是一份代码，支持多种数据类型。
三、引出泛型
3.1. 语法规则
java
class 泛型名称<参数列表>{
//这里可以使用类型参数;
}
class ClassName<T1,T2,......,Tn>{
}参数列表中要把类中会用的哪些类型列出来，后续使用这个类，创建实例的时候也要同时指定泛型参数的实参。T1,T2相当于类型的形参。
java
private T[] arrays = new T[];
//这种写法是错误的因为T要表示任何类型，new T[]的时候就可能会涉及到该类的构造方法，T是什么类型不知道该怎么办？就得先写成Object[]再进行强转。
java
T[] arrays = (T[]) new Object[];
java
class MyArray<T>{
T[] arrays = (T[]) new Object[10];
public T get(int index){
return arrays[index];//获取数组的下标
}
public void set(int index,T value){
arrays[index] = value;//对数组进行赋值
}
}
//上面的T不用再进行强转了
//对方法的实现
public class Main {
public static void main(String[] args) {
MyArray<String> array1 = new MyArray<String>();//里面可以存放字符。代码是灰色的，表示可以不写
MyArray<Integer> array2 = new MyArray<>();//里面可以存放整数
MyArray array4 = new MyArray();//裸类型，这种写法是不科学的
MyArray<int> array3 = new MyArray<>();//error: Type argument cannot be of primitive type
}
}3.2. 泛型的优点
1.代码重用，一份代码，支持多种类型； 2.自动地进行类型转化，编译过程中会自动触发一些类型检查。
四、类型擦除
4.1. 擦除的机制
Java的泛型，本质上是通过Object类进行编译的。编译器生成代码的时候，自动进行类型转化。比如下面的代码中的get方法，我要对T转化成String类型，编译器从数组中拿到的是一个Object类，然后进行自动转化成String类，返回到调用位置。在set方法里面，set String进来，编译器再自动把String转化成Object。
java
class MyArray<T>{
T[] arrays = (T[]) new Object[10];
public T get(int index){
return arrays[index];
}
public void set(int index,T value){
arrays[index] = value;
}
}下面是一段擦除的代码用例
java
//擦除前
class MyArray<T>{
public Object[] arrays = new Object[10];
public T getPos(int pos){
return (T)this.arrays[pos];
}
public void setVal(int pos,T val){
this.arrays[pos] = val;
}
}
//擦除后
class MyArray<T>{
public Object[] arrays = new Object[10];
public Object getPos(int pos){
return this.arrays[pos];
}
public void setVal(int pos,T val){
this.arrays[pos] = val;
}
}五、泛型的上界
5.1. 泛型的上界的定义
描述的是使用泛型，创建泛型实例的时候，传入的参数（类型实参）需要满足什么条件。
5.2. 语法规则
java
class 泛型名称<类型实参 extends 类型边界>{
}这个类型边界相当于是"父类"，后续创建类型实例的类型参数，必须是这个父类的子类。比如我们要写一个算术运算的泛型类，泛型参数必须给数字。
java
class MyArray<E extends Number>{
MyArray<Integer> l1;//正常
MyArray<String> l2;//错误
}如果没有指定类型边界E，可以视为E extends Object。
六、泛型方法
6.1. 定义语法
java
方法限定符 <类型形参列表> 返回值类型 方法名称{
}6.2. 交换方法的实例
java
public class Main {
//静态的泛型方法需要在static后面用<>声明泛型类型参数
public static <E> void swap(E[] array,int i,int j){
E t = array[i];
array[i] = array[j];
array[j] = t;
}
}七、通配符
前面的知识都是在定义泛型时涉及到的，通配符是针对泛型实例化的时候涉及到的。
java
class MyClass<T>{
}
public class Main {
public static void main(String[] args) {
MyClass<Integer> obj1 = new MyClass<>();
MyClass<String> obj2 = new MyClass<>();
MyClass<Integer> obj3 = new MyClass<>();
obj1 = obj3;//正常
obj1 = obj2;//错误
}
}因为Obj1与Obj2类型不相同，所以会报错。那我们能否创建一种引用，能够指向多种泛型参数的对象呢？这时就要用到通配符了。
java
MyClass<?> obj4 = obj3;
java
MyClass<? extends Number> obj5 = obj1;
obj5 = obj2;
//这个代码不符合要求，约定obj5的通配符，只能匹配到Number和它的子类;
//因为通配符只能在泛型实例化时使用这里的代码不要和泛型的上界搞混。我们除了可以指定父类，还能指定子类。
java
MyClass<? super Integer> obj6 = obj1;//此处的通配符只能匹配到Integer和它的父类
obj6 = new MyClass<double>();//double并不是Integer的子类，所以会报错
obj6 = new MyClass<Number>();//Number是Integer的父类。