泛型是JDK 5.0中引入的一个新特性。这个特性允许在类和接口的定义中使用类型参数。该类型参数在程序运行时被具体的类型替换。泛型就是类型参数的占位符。我们在学习API的类集框架时就使用过泛型来表示元素的类型。下面简单总结一下泛型的基础知识。
1. 使用泛型
最常见的使用带泛型的集合类：
import java.util.*;
public class Test
{
public static void main(String[] args)
{
ArrayList<Integer> array = new ArrayList<Integer>();
System.out.println(array.getClass().getName());
}
}
//运行结果：
//java.util.ArrayList因为泛型是在Java编译器中实现的，仅仅用作编译时类型检查，在编译得到的字节码中会被擦除。因此运行时的反射命令得到的array类型是ArrayList类而非ArrayList<Integer>类。利用这个特点，我们可以绕过编译时的泛型匹配检查，在运行时给集合类赋予与类型参数不符的元素。这同样要用到反射：
import java.util.*;
import java.lang.reflect.*;
public class Test
{
public static void main(String[] args) throws Exception
{
ArrayList<Integer> array = new ArrayList<Integer>();
array.getClass().getMethod("add", Object.class).invoke(array, "test");
System.out.println(array.get(0));
}
}
//运行结果
//test2. 泛型的兼容性和继承
类型参数非空的泛型类引用可以指向类型参数为空的泛型类实例，反之亦可。还是拿集合类来举例，比如：
ArrayList<Integer> array = new ArrayList();
ArrayList array2 = new ArrayList<Integer>();但是类型参数同样非空的引用和实例，若要求该引用指向该实例，需先保证两者类型参数严格一致：
//以下语句都报错：不兼容的类型
ArrayList<Integer> array = new ArrayList<String>();
ArrayList<Object> array2 = new ArrayList<Integer>();//编译通过
ArrayList[] array = new ArrayList[3];
//报错：创建泛型数组
ArrayList<Integer>[] array2 = new ArrayList<Integer>[3];3. 泛型通配符
3.1 形参的通配符
不考虑泛型的时候，一个方法的形参的类是传入对象的类或者其父类即可。如果不知道传入对象的具体类型，形参可以设置成Object类的对象。但若考虑泛型，则需要考虑前面说到的兼容性问题。如果方法在运行前只知道要传入一个泛型对象，但不知道具体的类型参数，这时由于类型参数没有继承关系，为了保证兼容性，可以使用泛型通配符"?"来表示此处有一个待定的类型参数（也可以不用，后面会提到）：
import java.util.*;
import java.lang.reflect.*;
public class Test
{
public static void main(String[] args) throws Exception
{
show(new ArrayList<Integer>());
}
public static void show(ArrayList<?> obj)
{
//打印“0”
System.out.println(obj.size());
//报错:找不到add(int)方法
obj.add(1);
//报错：找不到add(java.lang.Integer)方法
obj.add(new Integer(1));
//编译通过
obj = new ArrayList<String>();
}
}import java.util.*;
import java.lang.reflect.*;
public class Test
{
public static void main(String[] args) throws Exception
{
show(new ArrayList<Integer>());
}
//不使用通配符
public static void show(ArrayList obj)
{
//编译通过，但有警告
obj.add(1);
//编译通过，但有警告
obj.add("abc");
}
}3.2 非形参的通配符
如果一个引用不是形参，那可不可以用通配符呢？答案是可以：
//编译通过
ArrayList<?> array = new ArrayList();
//编译通过
ArrayList<?> array2 = new ArrayList<Integer>();
//报错：意外的类型，等号右边需要不带限制的类或接口
ArrayList<?> array3 = new ArrayList<?>();3.3 通配符的上下界
通配符不仅可以表示一个类型参数，还可以表示一定范围内的多个类型参数：ArrayList<? extends Number> array1 = new ArrayList<Integer>();
ArrayList<? extends Number> array2 = new ArrayList<Number>();
ArrayList<? super Integer> array3 = new ArrayList<Number>();
ArrayList<? super Integer> array4 = new ArrayList<Integer>();B表示该处类型参数是B类或者B的父类。前面提到类型参数没有继承关系指的是不用通配符时，类型参数为子类的泛型对象不能赋值给类型参数为父类的泛型引用。这里使用通配符表示类型参数的上下界，界内的泛型对象就可以赋值给泛型引用了，这也是使用通配符时的兼容性与不使用通配符时的兼容性不同的地方。
4. 自定义泛型
我们可以给类，接口和方法加入类型参数，也就是自定义泛型。
4.1 自定义泛型方法
泛型方法的类型参数的占位符要在返回值前的<>里注明，以区别于类的名称：
public class Test
{
public static void main(String[] args) throws Exception
{
show(1);
show("abc");
}
//<T>表示这是一个泛型方法，T是类型参数的占位符
public static <T> void show(T obj)
{
System.out.println(obj);
}
}
//运行结果：
//1
//abcpublic class Test
{
public static void main(String[] args) throws Exception
{
//编译方法时报错，所以该句不执行
//int a = add(2, 3);
//运行时报错：ClassCastException
String C = convert("abc", 1);
}
//编译时报错：" + "不能用于T, T
//public static <T> T add(T obj1, T obj2)
//{
// return obj1 + obj2;
//}
public static <A, B> A convert(A obj1, B obj2)
{
return (A) obj2;
}
}这里的类型参数占位符就如同前面的通配符。3.1和3.2中通配符仅出现在一个确定的类的类型参数位置上，比如ArrayList<?> a,表示集合元素的类不明确，但引用a的类仍然明确是ArrayList。上面例子中obj1的类本身都是不明确的。定义泛型时需要占位符，使用泛型时可以给这个占位符赋予具体的值, 这个值可以是通配符。
使用泛型进行类型转换能否成功，要考虑很多因素。
一是A，B两个类的父子关系：
public class Test
{
public static void main(String[] args) throws Exception
{
//警告
Object C = convert(new Object(), "abc");
}
public static <A, B> A convert(A obj1, B obj2)
{
return (A) obj2;
}
}二是多态：
public class Test
{
public static void main(String[] args) throws Exception
{
//编译通过，运行警告
Object obj1 = "abc";
String D = convert("abc", obj1);
//编译通过，运行报错：ClassCastException
Object obj2 = new Object();
String E = convert("abc", obj2);
}
public static <A, B> A convert(A obj1, B obj2)
{
return (A) obj2;
}
}总之，泛型的使用不能使得原本不可行的操作变成可行的，毕竟占位符也好，通配符也好，都是要替换成具体类型的。不明确某个对象所属的类，就不能对它进行不确定是否可行的操作。
4.2 自定义泛型类
当一个类中的多个泛型方法共用同样的类型参数时，可以将占位符从方法移到类定义处，成为自定义泛型类：
import java.util.*;
import java.lang.reflect.*;
public class Test
{
public static void main(String[] args) throws Exception
{
Operate<Integer> op = new Operate<Integer>();
op.print(1);
op.reflect(1);
}
}
class Operate<T>
{
ArrayList<T> array = new ArrayList<T>();
public void print(T obj)
{
System.out.println(obj);
}
public void reflect(T obj)
{
System.out.println(obj.getClass().getName());
}
public void add(T obj)
{
array.add(obj);
}
}
//运行结果：
//1
//java.lang.Integer5. 泛型的反射
前面提到过由于类型擦除的缘故，泛型引用的反射是无法得到类型参数的。
但是我们却可以用一种较为曲折的方法得到：
(1)建立一个包含该泛型的形参的方法；
(2)反射该方法所在的类得到该方法的类对象；
(3)通过Method类的getGenericParameterTypes()方法得到形参实际类型组成的数组，以及getGenericReturnType()方法得到返回值实际类型；
(4)从类型数组中取出泛型形参对应的类型；
(5)用ParameterizedType类的getActualTypeArguments()方法得到该泛型形参的类型参数：
但是我们却可以用一种较为曲折的方法得到：
(1)建立一个包含该泛型的形参的方法；
(2)反射该方法所在的类得到该方法的类对象；
(3)通过Method类的getGenericParameterTypes()方法得到形参实际类型组成的数组，以及getGenericReturnType()方法得到返回值实际类型；
(4)从类型数组中取出泛型形参对应的类型；
(5)用ParameterizedType类的getActualTypeArguments()方法得到该泛型形参的类型参数：
import java.util.*;
import java.lang.reflect.*;
public class Test
{
public static void main(String[] args) throws Exception
{
Vector<Integer> op = new Vector<Integer>();
//反射得到getGenerics()方法的类对象
Method GenericMethod = Test.class.getMethod("getGenerics", Vector.class);
//得到getGenerics()方法形参的类型参数
Type[] parameterType = GenericMethod.getGenericParameterTypes();
ParameterizedType pType = (ParameterizedType) parameterType[0];
System.out.println(pType.getActualTypeArguments()[0]);
//得到getGenerics()方法返回值的类型参数
Type returnType = GenericMethod.getGenericReturnType();
ParameterizedType rType = (ParameterizedType) returnType;
System.out.println(rType.getActualTypeArguments()[0]);
}
public Vector<Integer> getGenerics(Vector<Integer> tmp)
{
return null;
}
}
//运行结果：
//class java.lang.Integer
//class java.lang.Integer6. 总结
泛型的内容抽象且繁杂。笔者感觉要掌握好泛型，一是要能推断类型参数的实际值，二是能避免对泛型进行不可行的操作。第一个能力的掌握是第二个的前提。