我的博客即将入驻“云栖社区”，诚邀技术同仁一同入驻。
参考书籍
《Java核心技术：卷1》
泛型， 先睹为快
先通过一个简单的例子说明下Java中泛型的用法：
泛型的基本形式类似于模板， 通过一个类型参数T， 你可以"私人定制"一个类，具体定制的范围包括实例变量的类型，返回值的类型和传入参数的类型
Foo.java
public class Foo <T> {
// 约定实例变量的类型
private T data;
// 约定返回值的类型
public T getData () {
return this.data;
}
// 约定传入参数的类型
public void setData (T data) {
this.data = data;
}
}
Test.java
public class Test {
public static void main (String args[]) {
Foo<String> s = new Foo<String> ();
}
}
泛型的由来
泛型设计源于我们的编写类时的一个刚需：想让我们编写的处理类能够更加"通用", 而不是只能处理某些特定的对象或场景。或者说：我们希望我们的类能实现尽可能多的复用。举个栗子：一般来说，你并不想要编写多个分别处理不同数据类型，但内在逻辑代码却完全一样的类。因为这些处理类可能除了数据类型变换了一下外，所有代码都完全一致。“只要写一个模板类就OK了嘛~ 等要使用的时候再传入具体的类型，多省心”， 当你这么思考的时候：浮现在你脑海里的，就是泛型程序设计（Generic pogramming）的思想
在介绍Java的泛型机制之前， 先让我们来看看， 还没加入泛型机制的“泛型程序设计”是怎样子的
泛型程序设计1.0： 不用Java泛型机制
下面我们编写一个存储不同的对象的列表类，列表有设置（set）和取值（get）两种操作。
假设这个列表类为ObjArray，同时尝试存储的值为String类型，则：
1.在ObjArray类里我们维护一个数组arr, 为了将来能容纳不同的对象， 将对象设为Object类型（所有对象的父类）
2.在实例化ObjArray后， 通过调用set方法将String存入Object类型的数组中； 而在调用get方法时， 要对取得的值做强制类型转换—从Object类型转为String类型
ObjArray.java:
public class ObjArray {
private Object [] arr;
public ObjArray(int n) {
this.arr = new Object[n];
}
public void set (int i, Object o) {
this.arr[i] = o;
}
public Object get (int i) {
return this.arr[i];
}
}
Test.java:
/**
* @description: 测试代码
*/
public class Test {
public static void main (String args[]) {
ObjArray arr = new ObjArray(3);
arr.set(0, "彭湖湾");
// get操作时要做强制类型转换
String n =(String)arr.get(0);
// 输出 "彭湖湾"
System.out.print(n);
}
}
如果不使用泛型机制，但又想要实现泛型程序设计，就会编写出类似这样的代码。
泛型程序设计2.0： 使用Java泛型机制
让我们来看看使用泛型机制改进后的结果。
看起来大约是这样：
GenericArray.java
public class GenericArray<T> {
public void set (int i, T o) {
// ...
}
public T get (int i) {
// ...
}
}
【具体代码下面给出】
Test.java:
public class Test {
public static void main (String args[]) {
GenericArray<String> arr = new <String>GenericArray(3);
arr.set(0, "彭湖湾");
// 不用做强制类型转换啦~~
String s =arr.get(0);
// 输出： 彭湖湾
System.out.print(s);
}
}
我们发现，改进后的设计有以下几点好处：
1. 规范、简化了编码: 我们不用在每次get操作时候都要做强制类型转换了
2. 良好的可读性：GenericArray<String> arr这一声明能清晰地看出GenericArray中存储的数据类型
3. 安全性：使用了泛型机制后，编译器能在set操作中检测传入的参数是否为T类型， 同时检测get操作中返回值是否为T类型，如果不通过则编译报错
泛型并非无所不能
了解到了泛型的这些特性后， 也许你会迫不及待地想要在ObjArray类里大干一场。
例如像下面这样， 用类型参数T去直接实例化一个对象， 或者是实例化一个泛型数组
可惜的是 ......
public class GenericArray<T> {
private T obj = new T (); // 编译报错
private T [] arr = new T[3]; // 编译报错
// ...
}
没错， 泛型并不是无所不能的， 相反， 它的作用机制受到种种条框的限制。
这里先列举泛型机制的两个限制：
1.不能实例化类型变量， 如T obj = new T ();
2. 不能实例化泛型数组，如T [] arr = new T[3];
【注意】这里不合法仅仅指实例化操作（new）, 声明是允许的， 例如T [] arr
我们现在来继续看看上面泛型设计中， GenericArray类的那部分代码：
public class GenericArray<T> {
private Object [] arr;
public GenericArray(int n) {
this.arr = new Object[n];
}
public void set (int i, T o) {
this.arr[i] = o;
}
public T get (int i) {
return (T)this.arr[i];
}
}
没错， 在ObjArray类内部我们仍然还是用到了强制转型。看到这里也许令人有那么一点点的小失望， 毕竟还是没有完全跳出
初始的泛型设计的边界。 但是， 泛型的优点仍然是显而易见的， 只不过要知道的是：它并没有无所不能的魔法， 并受到诸多限制。
泛型的编写规则
1.泛型类和泛型方法的定义
泛型类
如前面所说，可以像下面一样定义一个泛型类
类型变量T放在类名的后面
public class Foo <T> {
// 约定实例变量的类型
private T data;
// 约定返回值的类型
public T getData () {
return this.data;
}
// 约定传入参数的类型
public void setData (T data) {
this.data = data;
}
}
泛型方法
也可以定义一个泛型方法：
泛型变量T放在修饰符（这里是public static）的后面， 返回类型的前面
public class Foo {
public static <T> T getSelf (T a) {
return a;
}
}
泛型方法可以定义在泛型类当中，也可以定义在一个普通类当中
2.可以使用多个类型变量
public class Foo<T, U> {
private T a;
private U b;
}
【注意】在Java库中，常使用E表示集合的元素类型， K和V分别表示关键字和值的类型， T（U，S）表示任意类型
3.JavaSE7以后，在实例化一个泛型类对象时，构造函数中可以省略泛型类型
ObjArray<Node> arr = new <Node>ObjArray();
可简写成：
ObjArray<Node> arr = new <>ObjArray();
类型变量的限定
当我们实例化泛型类的时候， 我们一般会传入一个可靠的类型值给类型变量T。 但有的时候，被定义的泛型类作为接收方，也需要对传入的类型变量T的值做一些限定和约束，例如要求它必须是某个超类的子类，或者必须实现了某个接口， 这个时候我们就要使用extends关键字了。如：
超类SuperClass：
public class SuperClass {
}
子类SubClass：
public class SubClass extends SuperClass {
}
对T使用超类类型限定：要求父类必须为SuperClass
public class Foo<T extends SuperClass> {
}
测试：
public class Test {
public static void main (String args[]) {
Foo<SubClass> f = new Foo<SubClass>(); // 通过
Foo<String> n = new Foo<String>(); // 报错
}
}
extends使用的具体规则
1. 对于要求实现接口， 或者继承自某个父类， 统一使用extends关键字 （没有使用implements关键字，为了追求简单）
2. 限定类型之间用 "&" 分隔
3. 如果限定类型既有超类也有接口，则：超类限定名必须放在前面，且至多只能有一个（接口可以有多个）
这个书写规范和类的继承和接口的实现所遵循的规则是一致的（<1>不允许类多继承，但允许接口多继承<2>书写类的时候类的继承是写在接口实现前面的）
// 传入的T必须是SuperClass的子类，且实现了Comparable接口
public class Foo<T extends SuperClass&Comparable> {
}
【注意】： 上面的SuperClass和Comparable不能颠倒顺序
泛型类的继承关系
泛型类型的引入引发了一些关于泛型对象继承关系的有趣（？）问题。
在Java中， 如果两个类是父类和子类的关系，那么子类的实例也都是父类的实例，这意味着：
一个子类的实例可以赋给一个超类的变量：
SubClass sub = new SubClass();
SuperClass sup = sub;
当引入了泛型以后， 有趣（？）的问题来了：
我们通过两对父子类List/ArrayList, Employee/Manager来说明这个问题
（我们已经知道List是ArrayList的父类（抽象类），这里假设Employee是Manager的父类）
1. ArrayList<Employee> 和 ArrayList<Manager>之间有继承关系吗？（ArrayList<Manager>的实例能否赋给ArrayList<Employee>变量？）
2. List<Employee> 和 ArrayList<Employee>之间有继承关系吗？（ArrayList<Employee>的实例能否赋给 List<Employee>变量？）
3. ArrayList和ArrayList<Employee>之间有继承关系吗？（ArrayList<Employee>的实例能否赋给ArrayList变量？）
答案如下：
对1： 没有继承关系； 不能
ArrayList<Manager> ae = new ArrayList<Manager>();
ArrayList<Employee> am = ae; // 报错
对2： 有继承关系； 可以
ArrayList<Employee> al = new ArrayList<>();
List<Employee> l = al; // 通过
对3： 有继承关系； 可以
ArrayList<Employee> ae = new ArrayList<>();
ArrayList a = ae;
下面用三幅图描述上述关系：
描述下1,2的关系
对上面三点做个总结：
1. 类名相同，但类型变量T不同的两个泛型类没有什么联系，当然也没有继承关系（ArrayList<Manager>和ArrayList<Employee>）
2. 类型变量T相同，同时本来就是父子关系的两个类， 作为泛型类依然保持继承关系 （ArrayList<Employee>和List<Employee>）
3. 某个类的原始类型，和其对应的泛型类可以看作有“继承关系”（ArrayList和ArrayList<Employee>）
引用一幅不太清晰的图
通配符？
泛型继承关系带来的问题 — 类型匹配的苦恼
问题出现在上面所述规范中的第二点：ArrayList<Manager> 和 ArrayList<Employee>之间没有继承关系。
这意味着，如果你像下面一样编写一个处理ArrayList<Employee>的方法
public class Foo {
public static void handleArr (ArrayList<Employee> ae) {
// ...
}
}
你将无法用它来处理ArrayList<Manager>：
public static void main (String args[]) {
ArrayList<Manager> am = new ArrayList<Manager>();
Foo.handleArr(am); // 报错，类型不匹配
}
现在我们想要：“handleArr方法不仅仅能处理ArrayList<Employee>， 而且还能处理ArrayList<X> （这里X代表Employee和它子类的集合）”。于是这时候通配符？就出现了：ArrayList<? extends Employee>能够匹配ArrayList<Manager>， 因为ArrayList<? extends Employee>是 ArrayList的父类
现在我们的例子变成了：
public class Foo {
public static void handleArr (ArrayList<? extends Employee> ae) {
// ...
}
}
public static void main (String args[]) {
ArrayList<Manager> am = new ArrayList<Manager>();
Foo.handleArr(am); // 可以运行啦！
}
通配符和super关键字
？统配不仅可以用于匹配子类型， 还能用于匹配父类型：
<? super Manager>
泛型的其他约束
上面我们介绍了泛型的一些约束，例如不能直接实例化实例化类型变量和泛型数组，这里和其他约束一起做个总结：
在定义泛型类时不能做的事：
1. 不能实例化类型变量
T obj = new T (); // 报错， 提示： Type parameter 'T' cannot be instantiated directly
解决方案：
如果实在要创建一个泛型对象的话， 可以使用反射：
public class GenericObj<T> {
private T obj;
public GenericObj(Class<T> c){
try {
obj = c.newInstance(); // 利用反射创建实例
} catch (Exception e) {
e.printStackTrace();
}
}
}
/**
* @description: 测试代码
*/
public class Test {
public static void main (String args[]) {
// 通过
GenericObj<String> go = new GenericObj<> (String.class);
}
}
因为Class类本身就是泛型， 而String.class是Class<T>的实例,
2. 不能实例化泛型数组，如T [] arr = new T[3];
private T [] arr = new T[3]; // 报错， 提示： Type parameter 'T' cannot be instantiated directly
解决方法一：
上文所提到的，创建Object类型的数组，然后获取时转型为T类型：
public class GenericArray<T> {
private Object [] arr;
public GenericArray(int n) {
this.arr = new Object[n];
}
public void set (int i, T o) {
this.arr[i] = o;
}
public T get (int i) {
return (T)this.arr[i];
}
}
解决方法二： 利用反射
这里使用反射机制中的Array.newInstance方法创建泛型数组
GenericArray.java
public class GenericArray<T> {
private T [] arr;
public GenericArray(Class<T> type, int n) {
arr = (T[])Array.newInstance(type, n); // 利用反射创建泛型类型的数组
}
public void set (int i, T o) {
this.arr[i] = o;
}
public T get (int i) {
return (T)this.arr[i];
}
}
Test.java
/**
* @description: 测试代码
*/
public class Test {
public static void main (String args[]) {
GenericArray<String> genericArr = new GenericArray<>(String.class, 5);
genericArr.set(0, "penghuwan");
System.out.println(genericArr.get(0)); // 输出 "penghuwan"
}
}
3. 不能在泛型类的静态上下文中使用类型变量
public class Foo<T> {
private static T t;
public static T get () { // 报错， 提示： 'Foo.this' can not be referenced from a static context
return T;
}
}
注意这里说的是泛型类的情况下。如果是在一个静态泛型方法中是可以使用类型变量的
public class Foo {
public static<T> T get (T t) { // 通过
return t;
}
}
（这里的泛型方法处在一个非泛型类中）
4. 不能抛出或者捕获泛型类的实例
不能抛出或者捕获泛型类的实例：
// 报错 提示：Generic class may not extend java.lang.throwable
public class Problem<T> extends Exception {
}
甚至扩展Throwable也是不合法的
public class Foo {
public static <T extends Throwable> void doWork () {
try {
// 报错 提示： Cannot catch type parameters
}catch (T t) {
}
}
}
但在异常规范中使用泛型变量是允许的
// 能通过
public class Foo {
public static <T extends Throwable> void doWork (T t) throws T {
try {
// ...
}catch (Throwable realCause) {
throw t;
}
}
}
在使用泛型类时不能做的事
1. 不能使用基本类型的值作为类型变量的值
Foo<int> node = new Foo<int> (); // 非法
应该选用这些基本类型对应的包装类型
Foo<Integer> node = new Foo<Integer> ();
2. 不能创建泛型类的数组
public static void main (String args[]) {
Foo<Node> [] f =new Foo<Node> [6]; // 报错
}
解决方法：
可以声明通配类型的数组， 然后做强制转换
Foo<Node> [] f =(Foo<Node> [])new Foo<?> [6]; // 通过
