一、包装类与基本类型

包装类，就是基本数据类型对应的类类型。我们已知Java中有8种基本数据类型，这些基本数据类型中除了int对应的包装类Integer、char对应的包装类Character其它包装类均为基本类型首字母大写。

装箱/装包： 把基本类型变为对应的包装类型

拆箱/拆包： 将包装类型拆箱为基本数据类型

//装箱/装包：把基本类型变为对应的包装类型
int a=10;
Integer val0 = (Integer)a;//自动装箱
Integer val1 = a;//自动装箱-->底层就是调用的是以下两个方法：

Integer val2 = Integer.valueOf(a);//手动装箱
Integer val3 = new Integer(a);    //手动装箱
		
//拆箱/拆包：将包装类型拆箱为基本数据类型
Integer value1 = 10;//这里存在自动装箱
int z = (int)value1;//自动拆箱
int a = value1;     //自动拆箱-->底层调用了以下方法：
int b = value1.intValue();//手动拆箱
double c = value1.doubleValue();//包装类的权限更大，可以拆成其它类型

一道有坑的面试题：

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);
}

先说结论，输出结果为 true、false.其实这道题就考察了装箱的底层原理，我们找到装箱源码：

二、泛型

1、什么是泛型

一般的类和方法，只能使用具体的类型: 要么是基本类型，要么是自定义的类。如果要编写可以应用于多种类型的代码，这种刻板的限制对代码的束缚就会很大。通俗讲，泛型：就是适用于许多许多类型。从代码上讲，就是对类型实现了参数化。

2、引出泛型

需求： 实现一个类，类中包含一个数组成员可以存放任意类型的数据。

根据我们已知的知识，Object类默认为所有类的父类（包括八大基本类型的包装类），所以我们可以创建一个Object类型的数组用来容纳各种类型的数据。具体实现如下：

class MyArrays {
    public Object[] obj = new Object[5];

    public Object getPos(int pos) {
        return obj[pos];
    }

    public void setPos(Object val,int pos) {
        obj[pos] = val;
    }
}

public class TestDemo {
    public static void main(String[] args) {
        MyArrays myArrays = new MyArrays();
        myArrays.setPos(6,0);
        myArrays.setPos("world",1);
        myArrays.setPos(10.5,2);
        int a = (int)myArrays.getPos(0);
        String str = (String)myArrays.getPos(1);
        double d = (double)myArrays.getPos(2);
    }
}

上面的Object数组确实可以实现什么类型的数据都能存储，但是也有一个问题：对于使用者来说，他们可能并不知道Object数组中每个下标存的到底是什么类型的数据，所以这就给使用时带来了麻烦。

结论：

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

3、泛型类的定义和使用

泛型语法

			//泛型类的定义
//概念化
class 泛型类名称<类型形参列表> {
	// 这里可以使用类型参数
}
			ↆ
//具体化
class ClassName<T1, T2, ..., Tn> {
	// 这里可以使用类型参数
}
			//泛型类的使用
泛型类<类型实参> 变量名 = new 泛型类<类型实参>(构造方法实参); // 实例化一个泛型类对象

按照上述规则，将上面引入改写：

class MyArray<T> {
	// 泛型数组（底层为Object）
    public Object[] obj = new Object[5];

    public void setObj(int pos,T val) {
        obj[pos]=val;
    }
    
    public T getPos(int pos) {
        return (T)obj[pos];
    }
}
//测试
public class TestDemo {
    public static void main1(String[] args) {
        MyArray<Integer> myArray = new MyArray<>();
        //可以推导出实例化需要的类型实参为 Integer,所以这里的<>中内容可省略
        myArray.setObj(0,1);
        myArray.setObj(1,2);
        myArray.setObj(2,3);
        int a = myArray.getPos(0);
        //myArray.setObj(4,"hello");//编译器会对类型检查，导致此处编译报错
    }
}

注解：

1. 类名后的 < T > 代表占位符，表示当前类是一个泛型类，T是类型形参（引用类型），一般使用一个大写字母表示，常用的名称有：
   (1) E 表示 Element
   (2) K 表示 Key
   (3) V 表示 Value
   (4) N 表示 Number
   (5) T 表示 Type
   (6) S, U, V 等等 - 第二、第三、第四个类型
2. 测试代码中，类型后加入 < Integer > 指定当前容器类型为Integer.
3. int a = myArray.getPos(0);不需要进行强制类型转换.
4. myArray.setObj(4,"hello");编译报错，是因为上面已指定类当前的类型为Integer，编译器会帮我们进行类型检查.
5. 泛型只能接受类，所有的基本数据类型必须使用包装类！
6. MyArray<Integer> myArray = new MyArray<>();当编译器可以根据上下文推导出类型实参时，可以省略类型实参的填写.
7. 错误定义方式T[] ts = new T[5];不能new泛型类型的数组.

4、擦除机制

在编译的过程当中，将所有的T替换为Object这种机制，我们称为：擦除机制。Java的泛型机制是在编译级别实现的。编译器生成的字节码在运行期间并不包含泛型的类型信息。对于泛型的编译这里我们就点到为止，目前先了解泛型有这样一个机制，想要真正理解泛型是需要时间和知识的打磨的！

5、泛型的上界

语法

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

例如：

//代表将来指定的参数E类型一定是实现了Comparable这个接口的
class Alg<E extends Comparable<E>> {

}

//E是Number的子类或者E是Number本身
class Alg2<E extends Number> {

}

使用场景： 实现一个泛型类，包含一个求数组最大值的方法。

分析： 由于类型形参E是一个引用类型，我们知道引用类型数值比较是不能直接使用大于小于号的，而是需要使用compareTo()比较方法，使用此方法又需要实现Comparable接口，而此时如果不使用泛型上界的话，最终E会被擦除为Object导致不能使用compareTo()方法，所以需要使用泛型上界E extends Comparable<E>

class Alg<E extends Comparable<E>> {
	//如果不使用泛型上界会导致E被擦除为Object，后面
    public E findMax(E[] array) {
        E max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (max.compareTo(array[i])<0) {
                max = array[i];
            }
        }
        return max;
    }
}
//测试
public class TestDemo {
    Alg<Integer> alg = new Alg<>();
    Integer[] array = {5,2,7,100,3,6,9};
    int max = alg.findMax(array);
    System.out.println(max);
}

6、泛型方法

语法

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

使用泛型方法改写上述求最大值泛型类：

class Alg2 {
    //这里将其改写成静态的方法
    public static  <E extends Comparable<E>> E findMax(E[] array) {
        E max = array[0];
        for (int i = 1; i < array.length; i++) {
            if(max.compareTo(array[i])<0) {
                max=array[i];
            }
        }
        return max;
    }
}
//测试
public class TestDemo {
    public static void main(String[] args) {
        Integer[] array1 = {1,2,3,4,5};
        Integer[] array2 = {6,7,8,9,10};
        int max2 = Alg2.<Integer>findMax(array2);
        //可以使用类型推导省略<>
        int max1 = Alg2.findMax(array1);
        System.out.println("array1的最大值为："+max1);
        System.out.println("array2的最大值为："+max2);
    }

7、通配符

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

在"?"的基础上又产生了两个子通配符：

（1）? extends 类：设置通配符上限

<? extends 上界>
<? extends Number>//可以传入的实参类型是Number或者Number的子类

（2）? super 类：设置通配符下限

<? super 下界>
<? super Integer>//代表 可以传入的实参的类型是Integer或者Integer的父类类型

特别注意： 使用 ? 通配符时，无法对泛型类型进行具体化操作，即不能将具体类型赋值给 ?。因此，在使用 ? 通配符的地方，只能进行读取操作（获取或比较），而不能进行写入操作（添加或修改）。这是为了保证类型安全性。

总结

到这里本文就结束了，或许读完本文你对泛型的理解还是萌萌懂懂，不过这都没关系，本篇文章的主要目的是能够对泛型在语法层面有一个基本的认知，想要真正理解泛型是需要时间和知识的打磨的！

到此断断续续的JavaSE也就告一段落了，总的来说Java的语法没有那么多弯弯绕绕，重点在于理解“面向对象”的概念。当然了JavaSE对于整个编程星球来说也只是一块敲门砖。路漫漫其修远兮，吾将上下而求索，我们下期再见喽！