包装类和泛型严格来说算得上是JavaSE的内容，为什么他们要放在数据集合中？

这和集合类有关，我们在集合类中将会用到大量的泛型和包装类。

1. 包装类

基本介绍

包装类（wrapper）是针对八大基本数据类型相应的引用类型。

既然我们叫他包装类，那么类中肯定有方法：

例如：Integer

那么包装类与基本数据类型的根本区别就在于能够调用方法，与此同时体现了面向对象。

我们先来看看吧大基本类型对应的包装类：

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

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

包装类和基本数据类型的转换

以int和Integer为例

1.jdk5前是手动装箱和拆箱的，装箱：基本类型 ——>包装类型。反之即为拆箱。

2.jdk5（含jdk5）是自动装箱和拆箱的。

3.自动装箱底层调用了valueOf方法。

public class demo {
    public static void main(String[] args) {
        int a = 10;
        Integer val =a;
    }
}

我们来看这段代码，它是如何进行自动拆箱和装箱的。

1. 先运行一遍程序，使之生成字节码文件

2.鼠标右键改Java文件，点击Explorer，如下图：

点击后：

再在目录表中输入cmd进入终端：

3.进入终端后输入指令进入反汇编：javap -c demo(你的.Java文件名)

我们在反汇编中找到了valuOf（）方法。

4. 在idea上选中Integer 按住ctrl + B 进入底层找到valuOf（）方法

传进来一个参数i ，返回时new 了一个Integer（i）。

所以：

        int a = 10;
        //Integer val =a;//自动装箱
        Integer val = Integer.valueOf(a);//显示装箱
        Integer val2 = new Integer(a);//显示装箱

我们用这两种方法显示装箱。

我们来看看拆箱：

public static void main(String[] args) {

        Integer val =10;
        int a = val;
        System.out.println(a);

    }

我们找到intValue ：

2. 泛型（Generic）

泛型的引出

泛型的主要目的：就是指定当前的容器，要持有什么类型的对象。让编译器去做检查。此时，就需要把类型，作为参数传递。需要什么类型，就传入什么类型。

比如：在ArrayList（顺序链表下一章就会讲）中添加数据，我们利用之前学的去添加，并不能对添加的数据类型进行约束（不安全）。

例如：在ArrayList中添加多条狗，但是一不小心传递了一只猫，我们再对其进行遍历，调用foreach需要向下转型（转为Dog），这再运行就会报异常

不使用泛型的情况下：

使用泛型后：

它就自动检查想要添加进来的类型。

基本介绍

1. 泛型又称参数化类型，是jdk5.0以后出现的新特征，解决数据类型安全问题。

2. 再类声明或实例化时只要指定好需要的具体类型即可。

3.Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会发生类型转换异常，同时代码更加健壮整洁。

4.泛型的作用是：可以在类声明是通过一个标识符表示某个属性的类型，或者某个方法的放回类型或者参数类型。

例如：

public class Main {
    public static void main(String[] args) {
        Person<Integer> integerPerson = new Person<>(123);
        Person<String> bit = new Person<>("bit");
    }
}

class Person<E> {
    E s ;//E表示S的数据类型，该数据类型在定义Person时指定，
    // 即在编译期间确定E是什么类型

    public Person(E s) {
        this.s = s;
    }
    public E f() {
        return s;
    }
}

语法声明

class 泛型类名称<类型形参列表> {
// 这里可以使用类型参数
}
class 类<K，V> {
}
class 泛型类名称<类型形参列表> extends 继承类/* 这里可以使用类型参数 */ {
// 这里可以使用类型参数
}
class 类<K，V> extends 类<T1> {
// 可以只使用部分类型参数
}

interface 接口<T> {

}

说明：

1. K、T、V不代表值，而是表示类型

2. 可以使用任意字母表示：

E 表示 Element
K 表示 Key
V 表示 Value
N 表示 Number
T 表示 Type
S, U, V 等等 - 第二、第三、第四个类型

3.类名后的 <T> 代表占位符，表示当前类是一个泛型类

泛型的使用细节和注意事项

1.interface 接口<T> { } 和public class HashSet<E>{ }

T和E只能是同类型的引用

2. 在给泛型指定具体类型后，可以传入该类型或其子类型

例：若指定类型为A类，又需要添加B类，可以B类先继承A类再添加

3.泛型的使用形式

方法1：
ArrayList<Integer> List = new ArrayList<Integer>();
在实际应用中我们一般这么写：
ArrayList<Integer> List = new ArrayList<>();
在我最开始学习面向对象的时候，看起来没有用到，其实默认是Object
Pig pig = new Pig();
//看起来啥都没有写，其实默认是<Objec>
//因为Objec 默认是所有类型的父类
//这也就是个裸类型

裸类型（Raw Type）（了解）

说明：

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

MyArray list = new MyArray();

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

泛型的编译

那么，泛型到底是怎么编译的？这个问题，也是曾经的一个面试问题。泛型本质是一个非常难的语法，要理解好他还是需要一定的时间打磨。

代码：以泛型数组为例：

public class demo {
    public static void main(String[] args) {
        MyArray<Integer> myArray = new MyArray<Integer>();

    }
}
class MyArray<E> {
     public E[] obj = (E[])new Object[3];

    public E[] getObj() {
        return obj;
    }

    public void setObj(E[] obj) {
        this.obj = obj;
    }
    
}

我们进入终端，输入指令：javap -c demo（.java文件名）

简单讲解一下反汇编的代码：

那么在程序编译好了以后跑进JVM，就没有了E[ ] 的概念了，我们泛型是在编译时期才存在的，一但程序运行起来以后，就不存在泛型这个概念了。E[ ] 在编译完成以后，就被擦除为了Object。

泛型在编译期间只做两件事：

1. 存储数据时，帮我们进行自动类型检查

2. 获取元素时，帮我们完成自动类型转换

有关泛型擦除机制的文章截介绍：
Java泛型擦除机制之答疑解惑 - 知乎 (zhihu.com)

自定义泛型

介绍：

1. 一般由单个字母大写表示；

2. 可以有多个大写字母,如： <T,R,M>

3. 普通成员也可以使用泛型

4. 使用泛型的数组不可以初始化（实例化），也就是不可以直接new；因为数组在new时无法确定T的类型，也就无法准确的开辟空间大小。

5. 静态的方法（属性）不可以使用泛型，在类加载时，自定义泛型还未创建（在创建对象时创建），所以JVM无法识别自定义泛型

自定义泛型接口

基本语法：

interface 接口名<T,R> { }

注意细节：

1. 接口中，静态成员也不可以使用泛型（原理如上）；

2.泛型接口的类型在继承或者实现接口是确定

3. 如不指定则为默认的Object

自定义泛型方法：

例：

class Car {
    public <T,R> void fly(T t, R r) {
        //实现的代码
    }
}

泛型的继承和通配符说明

1. 泛型不具备继承性

例如：

 MyArray<Integer> myArray = new MyArray<Object>();

2. 如果需要对传入的类型变量做一定的约束，可以通过类型边界来约束；我们称之为泛型的上界
语法：

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

还可以使用通配符，通配符类型（?）

例如：

<? extends A>//表示支持A类以及A的子类

？的默认是实现是<? extends Object>，表示?是继承Object的任意类型。

3. 有泛型的上界，也就有泛型的下界：

例如：

<? super A> // 表示支持A类以及A类的父类，并且不局限于A的直接父类

4. List<？>表示任意泛型类型均可接受

举个例子：

import java.util.ArrayList;
import java.util.List;

public class demo {
    public static void printCollection1(List<?> C) {
        for (Object object:C) {
            System.out.println(object);
        }
    }
    public static void printCollection2(List<? extends AA> C) {
        for (Object object:C) {
            System.out.println(object);
        }
    }
    public static void printCollection3(List<? super BB> C) {
        for (Object object:C) {
            System.out.println(object);
        }
    }

    public static void main(String[] args) {
        ArrayList<Object> list1 = new ArrayList<>();
        ArrayList<String> list2 = new ArrayList<>();
        ArrayList<AA> list3 = new ArrayList<>();
        ArrayList<BB> list4 = new ArrayList<>();
    }
}
class BB {
    
}
class AA extends BB {
    
}

我们的list1、list2、list3、list4均可以放入printCollection1（）中；

我们的list3、list4均可以放入printCollection2（）中；

我们的list1、list2均可以放入printCollection3（）中；