1. 包装类

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

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

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

1.2 （自动）装箱和（自动）拆箱

装箱（装包）： 把 基本数据类型 变为 包装类类型 的过程 叫做装箱。

反汇编指令：javap -c Test

也可以转换成不同的类型：

拆箱（拆包）： 把 包装类类型 变为 基本数据类型 的过程 叫做拆箱。

int i = 10;
Integer ii = i; // 自动装箱
Integer ij = (Integer)i; // 自动装箱
int j = ii; // 自动拆箱
int k = (int)ii; // 自动拆箱

面试题目：
下列代码输出什么，为什么？

public static void main(String[] args) {
Integer a = 127;
Integer b = 127;
Integer c = 128;
Integer d = 128;
System.out.println(a == b);
System.out.println(c == d);
}

解析：
思考问题抓住主要矛盾！！！！！！！！

2. 什么是泛型

一般的类和方法，只能使用具体的类型: 要么是基本类型，要么是自定义的类。如果要编写可以应用于多种类型的代码，这种刻板的限制对代码的束缚就会很大。----- 来源《Java编程思想》对泛型的介绍。
泛型是在JDK1.5引入的新的语法，通俗讲，泛型：就是适用于许多许多类型。从代码上讲，就是对类型实现了参数化。

3. 引出泛型

题目：
实现一个类，类中包含一个数组成员，使得数组中可以存放任何类型的数据，也可以根据成员方法返回数组中某个下标的值？

思路：

1. 我们以前学过的数组，只能存放指定类型的元素，例如：int[] array = new int[10]; String[] strs = newString[10];
2. 所有类的父类，默认为Object类。数组是否可以创建为Object?

代码示例：

class MyArray {
public Object[] array = new Object[10];
public Object getPos(int pos) {
return this.array[pos];
}
public void setVal(int pos,Object val) {
this.array[pos] = val;
}
}
public class TestDemo {
public static void main(String[] args) {
MyArray myArray = new MyArray();
myArray.setVal(0,10);
myArray.setVal(1,"hello");//字符串也可以存放
String ret = myArray.getPos(1);//编译报错
System.out.println(ret);
}
}

问题：

以上代码实现后 发现

1. 任何类型数据都可以存放
2. 1号下标本身就是字符串，但是确编译报错。必须进行强制类型转换
   虽然在这种情况下，当前数组任何数据都可以存放，但是，更多情况下，我们还是希望他只能够持有一种数据类型。而不是同时持有这么多类型。所以，泛型的主要目的：就是指定当前的容器，要持有什么类型的对象。让编译器去做检查。此时，就需要把类型，作为参数传递。需要什么类型，就传入什么类型。

3.1 语法

class 泛型类名称<类型形参列表> {
// 这里可以使用类型参数
}
class ClassName<T1, T2, ..., Tn> {
}
class 泛型类名称<类型形参列表> extends 继承类/* 这里可以使用类型参数 */ {
// 这里可以使用类型参数
}
class ClassName<T1, T2, ..., Tn> extends ParentClass<T1> {
// 可以只使用部分类型参数
}

注意：

了解： 【规范】类型形参一般使用一个大写字母表示，常用的名称有：
E 表示 Element
K 表示 Key
V 表示 Value
N 表示 Number
T 表示 Type
S, U, V 等等 - 第二、第三、第四个类型

4. 泛型类的使用

4.1 语法

MyArray<Integer> list = new MyArray<Integer>();

4.2 示例

MyArray<Integer> list = new MyArray<Integer>();

4.3 类型推导(TypeInference)

当编译器可以根据上下文推导出类型实参时，可以省略类型实参的填写。

MyArray<Integer>list = new MyArray<>();//可以推导出实例化需要的类型实参为Integer

5. 裸类型(RawType)（了解)

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

1. 泛型是将数据类型参数化，进行传递
2. 使用 表示当前类是一个泛型类。
3. 泛型目前为止的优点：数据类型参数化，编译时自动进行类型检查和转换

6. 泛型如何编译的

6.1 擦除机制

在编译的过程当中，将所有的T替换为Object这种机制，我们称为：擦除机制。
Java的泛型机制是在编译级别实现的。编译器生成的字节码在运行期间并不包含泛型的类型信息。

7. 泛型的上界

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

7.1 语法

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

7.2 示例

public class MyArray<E extends Number> {
...
}

只接受 Number 的子类型作为 E 的类型实参

MyArray<Integer> l1; // 正常，因为 Integer 是 Number 的子类型
MyArray<String> l2; // 编译错误，因为 String 不是 Number 的子类型

说明：
在Java中，Number 是一个抽象类，位于 java.lang 包中。它是所有数值类型的超类（父类），这些数值类型包括 Byte、Short、Integer、Long、Float、Double。

了解： 没有指定类型边界 E，可以视为 E extends Object。

复杂示例：

class Person implements Comparable<Person>{

    @Override
    public int compareTo(Person o) {
        return 0;
    }
}

//泛型类
class Alg<E extends Comparable<E>> {
//此时继承了Compareble  只有继承了Comparable类才能使用comparaTo方法
    public E findMax(E[] array) {
        E max = array[0];
        for (int i = 1; i < array.length; i++) {
            //if(max < array[i]) {//报错
            //我们并不知道E的类型是什么，如果没有规定E的类型，
            //Java会把E擦除成object，不管怎么样，擦除成object一定是一个引用类型
            //引用类型不能直接通过大于号，小于号进行大小比较，因为它不是基本数据类型
            //object中并没有实现任何接口 在这个泛型类继承了Comparable类时，
            //重写了comparaTo方法，就可以直接使用comparaTo来进行比较
            if(max.compareTo(array[i]) < 0) {
                max = array[i];
            }
        }
        return max;
    }
}

//泛型方法
class Alg2 {
    public<E extends Comparable<E>> E findMax(E[] array) {
        E max = array[0];
        for (int i = 1; i < array.length; i++) {
            //if(max < array[i]) {
            if(max.compareTo(array[i]) < 0) {
                max = array[i];
            }
        }
        return max;
    }
}

//静态的泛型方法（static）
class Alg3 {
    public static <E extends Comparable<E>>  E findMax(E[] array) {
        E max = array[0];
        for (int i = 1; i < array.length; i++) {
            //if(max < array[i]) {
            if(max.compareTo(array[i]) < 0) {
                max = array[i];
            }
        }
        return max;
    }
}
public class TestGeneric {
    public static void main(String[] args) {
        Integer[] array = {1,2,3,4,45,5,6,8};
        int ret = Alg3.findMax(array);
        //不需要new一个新对象，可以通过类名直接调用findmax
        System.out.println(ret);
    }
    
    public static void main2(String[] args) {
        Alg2 alg2 = new Alg2();
        //alg2是一个方法，不会像泛型类一样在实例化的时候传一个类型（泛型参数）
        Integer[] array = {1,2,3,4,45,5,6,8};
        int ret = alg2.findMax(array);
        //问：在调用findmax时，是怎么知道当前是一个integer类型呢？
        //答：会根据传入的array的类型，推测出来这个E到底是什么
        //int ret = alg2.<Integer>findMax(array);
        System.out.println(ret);
    }
    
    public static void main1(String[] args) {
        Integer[] array = {1,2,3,4,45,5,6,8};
        Alg<Integer> alg = new Alg<>();
        int a = alg.findMax(array);
        //Integer中本身就已经实现了comparable接口，此时就可以直接用
        System.out.println(a);

        Alg<Person> alg23 = new Alg<Person>();

    }
}

8. 泛型方法

方法限定符 <类型形参列表> 返回值类型 方法名称(形参列表) { ... }

8.2 示例

看7.2中的复杂示例，三种方式结合着看，注意理解！！！