一、泛型的引入
我们想求两个数的最大值
public static void func(int n,int m) {
System.out.println(n > m ? n : m);
}
public static void main(String[] args) {
func(2,3);
func(1.5,2.5);
}1
2
3
4
5
6
7
但我们方法就写死了，只能求整形的最大值，那我们要求两个浮点数的呢，两个对象的呢?
泛型的出现：
集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个参数，这个类型参数叫做泛型。Collection，List，ArrayList 这个就是类型参数，即泛型
Object类是所有类的父类，它可以接收任意类型的数据，这里以接受String类型为例，在直接接收obj类型时，会报错。
public static void main(String[] args) {
Object obj = new Object();
obj = "dachang";
String str = (String)obj;
}1
2
3
4
5
泛型的主要目的：就是指定当前的容器，要持有什么类型的对象。让编译器去做检查
二、基本数据类型和对应包装类
在Java中，由于基本类型不是继承于Object，为了在泛型代码中可以支持基本类型，Java给每个基本类型都对应了一个包装类型。
基本数据类型 包装类
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
大部分基本类型的包装类都是首字母大写，除了Int的包装类为Integer,char的包装类为Character
三、初使用泛型
实现一个类，类中包含一个数组成员，使得数组中可以存放任何类型的数据，也可以根据成员方法返回数组中某个下标的值？
class InitArray{
public Object[] arr = new Object[10];
public Object getPos(int pos) {
return arr[pos];
}
public void setVal(int pos,Object val) {
this.arr[pos] = val;
}}
public static void main(String[] args) {
InitArray initArray = new InitArray();
initArray.setVal(0,true);//可以存放boolean类型
initArray.setVal(1,10.5);//可以存放double类型
boolean b = initArray.getPos(0);//编译报错
double f = initArray.getPos(1);//编译报错
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Object数组任何类型数据都可以存放，但在进行接受时，编译器就会报错，必须要进行类型转换。
在更多的情况下，我们还是希望它只能放同种类型。需要什么类型，我们传入什么参数就可以，泛型就是为此而生
用泛型实现：
class InitArray {
public T[] arr = (T[])new Object[10];
public T getPos(int pos) {
return arr[pos];
}
public void setVal(int pos,T val) {
this.arr[pos] = val;
}}
public static void main(String[] args) {
InitArray<Integer> initArray = new InitArray<>();
initArray.setVal(0,10);
initArray.setVal(1,5);
int a = initArray.getPos(0);
int b = initArray.getPos(1);
System.out.println(a);
System.out.println(b);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
我们发现这里我们没有进行强制类型转换，并且顺利输出了。
代码解释：
1.
这里的InitArray是泛型类，代表占位符，就表示当前类是一个泛型类，大家不必去追问为啥是T，这里只是一个变量名而已，常见的还有:
名称 表示
E Element
K Key
V Value
N Number
T Type
2.
不再需要强制类型转换。
3.
编译器会帮助我们检查代码，如果类型不一致会报错。
4.
类型后面的指定当前类型。
5.无法new 一个泛型类型的数组。
T[] t = new T[10];
1
所以不存在上面这种方式。
四、泛型的编译
1 擦除机制
我们查看一下字节码文件
在编译的过程中我们发现所有的T都被替换为了Object，我们把这种机制称为: 擦除机制。
编译器生成的字节码在运行期间不包含任何泛型的类型信息。
2 为什么不能实例化泛型类型数组？
根据擦除机制可知，在编译阶段所有的T被替换为了Object，那为什么，T[] ts = new T[5]; 是不对的，编译的时候，替换为Object，不是相当于：Object[] ts = new Object[5]吗？
由于无法创建泛型数组，我们换个例子去验证
class MyArray {
public T[] arr = (T[])new Object[10];
public T getPos(int pos) {
return this.arr[pos];
}
public void setVal(int pos,T val) {
this.arr[pos] = val;
}
public T[] getArr() {
return arr;
}}
public static void main(String[] args) {
MyArray<Integer> myArray = new MyArray<>();
Integer[] arr = myArray.getArr();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
替换之后，将Object[ ]传给Integer[ ]，因为Object数组里可能存放的是任何类型的数据，直接转给Integer数组是不安全的，所以程序报类型转换异常。具体来说，数组是在运行时存储和检查类型信息，而泛型是在编译时检查错误，如果泛型可以创建数组，那么这里就有很大的安全隐患。
public T[] arr = (T[])new Object[10];
1
那这样使用好吗？ 是的不好，但我们目前学习的知识只能使用到这，其实这样使用也会有安全隐患，下面举一个安全的使用方法，了解即可:
class MyArray {
public T[] arr;
public MyArray() {
}
//这里通过反射，创建一个类型为指定类型的数组，了解即可。
public MyArray(Class<T> clazz,int capacity) {
arr = (T[]) Array.newInstance(clazz,capacity);
}
public T getPos(int pos) {
return this.arr[pos];
}
public void setVal(int pos,T val) {
this.arr[pos] = val;
}
public T[] getArr() {
return arr;
}}
public static void main(String[] args) {
MyArray<Double> myArray = new MyArray<>(Double.class,10);
Double[] arr = myArray.getArr();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
这样就可以顺利转换了，避免了安全隐患。
3 类型擦除，一定是把T变为Object吗？
不是的，目前我们看到的确实T全部变为了Object，但当T指定了类型参数的上界的话，则使用这个上界，下一篇博客我会具体介绍泛型上界。
