目录
1. 包装类
1.1 基本数据类型和对应的包装类
1.2 装箱和拆箱
1.3 一道面试题
2. 泛型
2.1 什么是泛型
3. 泛型是如何编译的
3.1 擦除机制
4. 泛型的上界
5. 泛型方法
1. 包装类
在 Java 中，由于基本类型不是继承自 Object，为了在泛型代码中可以支持基本类型，Java 给每个基本类型都对应了 一个包装类型。如此一来，基本数据类型也能面向对象编程了。
1.1 基本数据类型和对应的包装类
| 基本数据类型 | 包装类 |
| byte | Byte |
| short | Short |
| int | Integer |
| long | Long |
| float | Float |
| double | Double |
| char | Character |
| boolean | Boolean |
除了 Integer 和 Character， 其余基本类型的包装类都是首字母大写。
1.2 装箱和拆箱
装箱，也叫装包，把基本数据类型变为对应的包装类。
public static void main(String[] args) {
int a = 10;
//Integer val = a; //自动装箱
//Integer val = (Integer)a;//自动装箱
Integer val = Integer.valueOf(a); //显示装箱
//Integer val = new Integer(a); //显示装箱
System.out.println(val);
}拆箱，也叫拆包，把包装类转变成基本数据类型。
public static void main(String[] args) {
Integer val = 100;
int i = val; //自动拆箱
//int i = (int)val; //自动拆箱
System.out.println(i);
int j = val.intValue(); //显示拆箱，拆成 int 类型
System.out.println(j);
double k = val.doubleValue(); //显示拆箱，拆成 double 类型
System.out.println(k);
float l = val.floatValue(); //显示拆箱，拆成 float 类型
System.out.println(l);
}1.3 一道面试题
下面代码输出什么？
public static void main(String[] args) {
Integer a = 100;
Integer b = 100;
System.out.println(a == b);
Integer c = 200;
Integer d = 200;
System.out.println(c == d);
}输出
true
false
IntegerCache 是 Integer 中的内部类，low 的值为 -128，而 high 的值为 127，cache 是一个数组：
在 valueOf 这个方法中，如果i ∈[-128，127]，则返回 cache 数组里的元素：
但如果 i 超出范围，那么就会返回 new 一个对象。根据前面所学我们知道，== 比较的是地址，所以比较的结果才会使 false。
2. 泛型
2.1 什么是泛型
一般的类和方法，只能使用具体的类型: 要么是基本类型，要么是自定义的类。如果要编写可以应用于多种类型的代码，这种刻板的限制对代码的束缚就会很大。
泛型是在 JDK1.5 引入的新的语法，通俗讲，泛型：就是适用于许多许多类型。从代码上讲，就是对类型实现了参数化。
在介绍泛型之前，能不能实现一个类，类中包含一个数组成员，使得数组中可以存放任何类型的数据，也可以根据成员方法返回数组中某个下标的值？
思路：
1. 我们以前学过的数组，只能存放指定类型的元素，例如：int[] array = new int[10]; String[] strs = new String[10];
2. 所有类的父类，默认为 Object 类。数组是否可以创建为 Object ?
class MyArray{
public Object[] obj = new Object[3];
public Object getPos(int pos){
return obj[pos];
}
public void setObj(int pos,Object val){
obj[pos] = val;
}
}
public class Text {
public static void main(String[] args) {
MyArray myArray = new MyArray();
myArray.setObj(0,100);
myArray.setObj(1,"hello");
myArray.setObj(2,10.5);
int a = (int)myArray.getPos(0); //拆箱
String b = (String)myArray.getPos(1); //拆箱
double c = (double)myArray.getPos(2); //拆箱
System.out.println(a);
System.out.println(b);
System.out.println(c);
}
}上述数组的确可以存储任何类型的数据，但读取时，却需要强转。更多情况下，我们还是希望他只能够持有一种数据类型。而不是同时持有这么多类型。所以，泛型的主要目的：就是指定当前的容器持有特定类型的对象。此时，需要把类型，作为参数传递。需要什么类型，就传入什么类型：
class MyArray<T>{
public T[] obj = (T[])new Object[3]; //*
public T getPos(int pos){
return obj[pos];
}
public void setObj(int pos,T val){
obj[pos] = val;
}
}
public class Text {
public static void main(String[] args) {
//实例化对象的同时，指定当前泛型类的指定参数类型是 Integer
MyArray<Integer> myArray = new MyArray<Integer>(); //**
//就可以存储指定的数据类型
myArray.setObj(0,100); //#
myArray.setObj(1,121);
myArray.setObj(2,141);
int a = myArray.getPos(0); //***
System.out.println(a);
System.out.println("==========================");
//实例化对象的同时，指定当前泛型类的指定参数类型是 String ，第二个< >的内容可以省略
MyArray<String> myArray1 = new MyArray<>();
myArray1.setObj(0,"haha");
myArray1.setObj(1,"heihei");
myArray1.setObj(2,"hehe");
String b = myArray1.getPos(1);
System.out.println(b);
}代码解释：
1. 类名后的<T>代表占位符，表示当前类是一个泛型类
了解：
【规范】类型形参一般使用一个大写字母表示，常用的名称有：
E 表示 Element
K 表示 Key
V 表示 Value
N 表示 Number
T 表示 Type
S, U, V 等等 - 第二、第三、第四个类型
2. 注释 * 处，不能 new 泛型类型的数组，即泛型类当中，不能实例化一个泛型类数组：
T[] ts = new T[3];//是不对的
3. 泛型是把类型作为参数传递，泛型只能接受类，所有的基本数据类型必须使用包装类！注释 ** 处，< >里指定的参数类型必须是引用类型，而不能是基本数据类型
4. 注释 *** 处，不需要进行强制类型转换，编译器会自动帮我们数据转换
5. 注释 # 处，编译器会在存放元素的时候帮助我们进行类型检查
第四、第五点是泛型在编译时完成的。
3. 泛型是如何编译的
3.1 擦除机制
那么，泛型到底是怎么编译的？
IDEA 点击 View -> Show ByteCode :
可以看到，在编译完成之后，编译器将所有的 T 替换为 Object ，这种机制，我们称为：擦除机制。 Java 的泛型机制是在编译级别实现的。编译器生成的字节码在运行期间并不包含泛型的类型信息。
官方中，对于泛型类的数组声明是不写成这样的：public T[] obj = (T[])new Object[3];
官方的正确写法：
class MyArray<T>{
//public T[] obj = (T[])new Object[3];
public Object[] obj = new Object[3]; //在 Java 官方中，泛型类中的数组声明
public T getPos(int pos){
return (T)obj[pos];
}
public void setObj(int pos,T val){
obj[pos] = val;
}
}4. 泛型的上界
由于泛型的擦除机制会将传入的类型变量擦除成 Object 类，但有时需要对传入的类型变量做一定的约束，可以通过类型边界来约束。
class 泛型类名称 <类型形参 extends 类型边界> {
......
}
类型边界有两种，一是接口，意味着指定的参数类型一定实现了该接口，二是某一具体类，意味着形参是该类的子类，或是该类本身。
示例1：
类型边界为接口：找到数组中的最大值
class Alg<E extends Comparable>{
public E findMax(E[] arrays){
E max = arrays[0];
for (int i = 1; i < arrays.length; i++) {
if(max.compareTo(arrays[i]) < 0){
max = arrays[i];
}
}
return max;
}
}
public class Text {
public static void main(String[] args) {
Alg<Integer> alg = new Alg<>();
Integer[] arr = {1,2,5,7,24,62,555,36,77,42,31,59,92};
Integer max = alg.findMax(arr);
System.out.println(max);
}
}示例2：
类型边界为 Number 类：
通过查询帮助手册可知，Number 有以下我们所熟悉的包装类：
5. 泛型方法
基本语法：
方法限定符 <类型形参列表 extends 边界类型>返回值类型 方法名称(形参列表) {
......
}
class Alg1 {
public<E extends Comparable<E>> E findMax1(E[] arrays){
E max = arrays[0];
for (int i = 1; i < arrays.length; i++) {
if(max.compareTo(arrays[i]) < 0){
max = arrays[i];
}
}
return max;
}
}
public class Text {
public static void main(String[] args) {
Alg1 alg1 = new Alg1();
Integer[] arr = {1,2,5,7,24,62,555,36,77,42,31,59,92};
Integer max = alg1.<Integer>findMax1(arr);
//也可以省略：Integer max = alg1.findMax1(arr);
System.out.println(max);
}
}也可以使用泛型的静态方法：
class Alg2 {
public static <E extends Comparable<E>> E findMax1(E[] arrays){
E max = arrays[0];
for (int i = 1; i < arrays.length; i++) {
if(max.compareTo(arrays[i]) < 0){
max = arrays[i];
}
}
return max;
}
}
public class Text {
public static void main(String[] args) {
Integer[] arr = {1,2,5,7,24,62,555,36,77,42,31,59,92};
Integer max = Alg2.findMax1(arr);
System.out.println(max);
}
}
