Java泛型总结

概述

从java 5以后，增加了参数化类型的概念。
泛型(Generic)，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。
那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

未使用泛型前

编译时不检查类型的异常

public static void main(String[] args) {
		List strList = new ArrayList();
		strList.add("book 1");
		strList.add("book 2");
		strList.add(3);

		for (int i = 0; i < strList.size(); i++) {
			String item = (String) strList.get(i);
			System.out.println(item);
		}
	}

运行后，会遇到下面的错误：
java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
因为在没有使用泛型前，放入集合的元素会被当作Object类型。

如果使用泛型，修改上面的代码：

List<String> strList = new ArrayList<String>();

这行代码：strList.add(3); 就会编译错误。使用泛型可以提高程序的健壮性。

Java 7的菱形语法

从Java 7 以后，允许在构造器后面不需要带完整的泛型信息，只需要给出一对尖括号即可。java可以自动判断尖括号里是什么泛型信息。
修改上面的语句如下：

List<String> strList = new ArrayList<>();

泛型的使用

Java 5 改写集合框架中的全部接口和类，为他们增加了泛型支持。
具体格式可以参考集合框架中的经典实现。

泛型接口

例如List接口，定义接口时定义了一个类型形参，形参名为E

public interface List<E> extends Collection<E> {
	boolean add(E e);
	Iterator<E> iterator();
	...
}

例如Map接口，定义接口时定义了类型形参，形参名为K，V

public interface Map<K,V> {
	V put(K key, V value);
	...
}

泛型类

例如HashMap类，定义类时定义了类型形参，形参名为K，V

public class HashMap<K,V>
    extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable
{
	public V put(K key, V value) {
	...
	}
}

类型形参在整个接口和类内，可以被当作类型使用，几乎所有可以使用普通类型的地方都可以使用这种类型形参。

自定义泛型类

可以为任何类添加泛型声明

public class Person<T> {

	// 使用T类型形参定义实例变量
	private T info;

	public Person() {

	}

	public Person(T info) {
		this.info = info;
	}

	public T getInfo() {
		return info;
	}

	public void setInfo(T info) {
		this.info = info;
	}

	public static void main(String[] args) {
		// 由于传给T形参的是String，所以构造器参数只能是String
		Person<String> person1 = new Person<>("Tom");
		System.out.println(person1.getInfo());
		
		// 由于传给T形参的是int，所以构造器参数只能是Integer
		Person<Integer> person2 = new Person<>(20);
		System.out.println(person2.getInfo());
	}
}

注意到，自定义类中的构造器名还是原来的类名，不要增加泛型声明。
但是，在调用构造器时，可以使用Person<T>的形式，或者使用菱形语法Person<>的形式。

从泛型类派生子类

可以从泛型类派生子类，注意事项如下：如果重写父类方法时，也要注意返回类型等。

下面这种定义方法，就会报编译错误

public class SubPerson extends Person<T>{
	...
}

可以修改上面的代码，如下，

public class SubPerson extends Person<String>{
	...
}

或者，不为类型形参传入实际的类型参数，但是Java编译器会发出警告。系统会把T形参当作Object处理。

public class SubPerson extends Person{
	...
}

另外这种定义也是可以的

public class SubPerson<T> extends Person<T>{
	...
}

不存在的泛型类

不管为泛型类的形参传入哪一种类型参数，对于Java来说，他们依然是被当作同一个类来处理，在内存中也只占用同一块内存空间。
因此在静态方法、静态初始化块或者静态变量的声明和初始化中不允许使用类型形参。

public class GenericTest<T> {

	// 代码错误，静态变量的声明中不允许使用类型形参
	static T info;
	
	T info2;

	public void test1(T para) {

	}

	// 代码错误，静态方法的声明中不允许使用类型形参
	public static void test2(T para) {

	}
}

由于系统中不会生成真正的泛型类，所以instanceof运算符不能用于比较泛型类。

Collection<String> collection = new ArrayList<>();
// 代码错误，
// Cannot perform instanceof check against parameterized type ArrayList<String>. Use the form ArrayList<?> instead since further generic type information will be erased at runtime
if(collection instanceof ArrayList<String>){
	...
}

泛型通配符

例子：

public static void test(List<Object> list) {
	for (int i = 0; i < list.size(); i++) {
		System.out.println(list.get(i));
	}
}

// 测试代码
List<String> list = new ArrayList<>();
list.add("Tom");
list.add("Jerry");
// 编译错误
// The method test(List<Object>) in the type GenericTest is not applicable for the arguments (List<String>)
test(list);

注意：
数组和泛型有所不同，假设sub是base的一个子类型（子类或者子接口），那么sub[]依然是base[]的子类型；但是G<sub>不是G<base>的子类型。

泛型设计原则：
只要代码在编译阶段没有出现警告，就不会遇到运行时ClassCastException异常。

使用类型统配符

为了表示各种泛型List的父类，可以使用类型统配符，用一个问号(?)表示。修改上面的代码，如下：

public static void test(List<?> list) {
	for (int i = 0; i < list.size(); i++) {
		System.out.println(list.get(i));
	}
}

List<String> list = new ArrayList<>();
list.add("Tom");
list.add("Jerry");
// 正常编译，程序可以运行
test(list);

带统配符的List<?>仅表示它是各种泛型List的父类，但是不能向里面添加元素。

List<?> list1 = new ArrayList<>();
// 这行代码没有问题，可以获取元素，虽然类型未知，但是一定是一个Object
list1.get(0);
// 编译错误
// The method add(capture#3-of ?) in the type List<capture#3-of ?> is not applicable for the arguments (Object)
// 因为程序无法确定list1集合中的元素的类型
list1.add(new Object());