Java中泛型

主要内容

详细内容

概述

体验泛型

泛型是提供给javac编译器使用的，可以限定集合中的输入类型，可以让编译器挡住源程序中的非法输入，编译器编译带类型说明的集合时会去掉“类型”信息，使程序运行效率不受影响，对于参数话的泛型类型，getClass()方法的返回值和原始类型完全一样。

由于编译器生成的字节码会去掉类型信息，只要能跳过编译器，就可以往某个泛型集合中加入其它类型中的数据。例如，使用反射得到集合，然后调用其add方法便可实现。

了解泛型

（1）ArrayList<E>类定义和ArrayList<Integer>类引用中涉及如下术语：

整个称为ArrayList<E>泛型类型
ArrayList<E>中的E称为类型变量或类型参数
整个ArrayList<Integer>称为参数化的类型
ArrayList<Integer>中的Integer称为类型参数的实例或实际类型参数
ArrayList<Integer>中的<>念着typeof
ArrayList称为原始类型

（2）参数化类型与原始类型的兼容性：

参数化类型可以引用一个原始类型的对象，编译报告警告，例如，

 Collection<String> c = new Vector();//可不可以，不就是编译器一句话的事吗？

原始类型可以引用一个参数化类型的对象，编译报告警告，例如，

Collection c = new Vector<String>();//原来的方法接受一个集合参数，新的类型也要能传进去

（3）参数化类型不考虑类型参数的继承关系：

Vector<String> v = new Vector<Object>(); //错误!///不写<Object>没错，写了就是明知故犯

Vector<Object> v = new Vector<String>(); //也错误!

（4）编译器不允许创建泛型变量的数组。即在创建数组实例时，数组的元素不能使用参数化的类型，例如，下面语句有错误：

  Vector<Integer> vectorList[] = new Vector<Integer>[10];

总结：

（1）在使用泛形时，两边如果同时用到了泛形，两边就必须一致；

（2）在使用泛形时，如果只有一边使用到了泛形，这是可以的。

类型通配符

使用类型通配符

类型通配符是一个问号（？），它的元素类型可以匹配任何类型；比如将一个问号作为类型实参传递给List集合，写作List<?>。

限定通配符的上边界

 ？ extends E: 可以接收E类型或者E的子类型

正确：Vector<? extends Number> x = new Vector<Integer>();

错误：Vector<? extends Number> x = new Vector<String>();

限定通配符的下边界

？ super E: 可以接收E类型或者E的父类型

正确：Vector<? super Integer> x = new Vector<Number>();

错误：Vector<? super Integer> x = new Vector<Byte>();

总结：

（1）限定符总是包括自己；

（2）？只能用作引用，不能用它去给其它变量赋值，只能通过强制类型转换方式来赋值。

综合案例

对HashMap集合的三种迭代方式：

public class GenericMapDemo
{
	public static void main(String[] args)
	{
		entrySet();
		keySet();
		onePointFive();
	}

	// 使用传统方式迭代Map集合
	public static void entrySet()
	{
		Map<Integer, String> map = new HashMap<Integer, String>();
		map.put(1, "aaa");
		map.put(2, "bbb");
		map.put(3, "ccc");
		Set<Map.Entry<Integer, String>> set = map.entrySet();
		Iterator<Map.Entry<Integer, String>> it = set.iterator();
		while (it.hasNext())
		{
			Map.Entry<Integer, String> entry = it.next();
			int key = entry.getKey();
			String value = entry.getValue();
			System.out.println(key + " --> " + value);
		}
	}

	// 使用传统方式2迭代Map集合
	public static void keySet()
	{
		Map<Integer, String> map = new HashMap<Integer, String>();
		map.put(1, "aaa");
		map.put(2, "bbb");
		map.put(3, "ccc");
		Set<Integer> set = map.keySet();
		Iterator<Integer> it = set.iterator();
		while (it.hasNext())
		{
			int key = it.next();
			String value = map.get(key);
			System.out.println(key + " --> " + value);
		}
	}

	// 使用1.5以后的新方式
	public static void onePointFive()
	{
		Map<Integer, String> map = new HashMap<Integer, String>();
		map.put(1, "aaa");
		map.put(2, "bbb");
		map.put(3, "ccc");
		for (Map.Entry<Integer, String> entry : map.entrySet())
		{
			int key = entry.getKey();
			String value = entry.getValue();
			System.out.println(key + " --> " + value);
		}
	}
}

泛型方法

自定义泛型产生的原因

如下三个函数的结构很相似，但类型不同；

int add(int x,int y)
{ 
	return x+y;
}
float add(float x,float y)
{ 
	return x+y;
}
double add(double x,double y)
{ 
	return x+y;
}

C++用模板函数解决，只写一个通用的方法，它可以适应各种类型，示意代码如下：

template<class T> 
T add(T x,T y) {
　　return (T) (x+y);
}

Java中的泛型类型（或者泛型）类似于 C++ 中的模板。但是这种相似性仅限于表面，Java 语言中的泛型基本上完全是在编译器中实现，用于编译器执行类型检查和类型推断，然后生成普通的非泛型的字节码，这种实现技术称为擦除（erasure）（编译器使用泛型类型信息保证类型安全，然后在生成字节码之前将其清除）。这是因为扩展虚拟机指令集来支持泛型被认为是无法接受的，这会为 Java 厂商升级其 JVM 造成难以逾越的障碍。所以，java的泛型采用了可以完全在编译器中实现的擦除方法。

定义泛型方法

（1）当某个类型变量只在整个参数列表中的所有参数和返回值中的一处被应用了，那么根据调用方法时该处的实际应用类型来确定，这很容易凭着感觉推断出来，即直接根据调用方法时传递的参数类型或返回值来决定泛型参数的类型

比如：交换数组中的两个元素的位置的泛型方法语法定义如下：

// 编写一个方法实现数组元素的交换
public <T> void swap(T arr[], int pos1, int pos2)
{
	T temp = arr[pos1];
	arr[pos1] = arr[pos2];
	arr[pos2] = temp;
}

（2）普通方法、构造方法和静态方法中都可以使用泛型。也可以用类型变量表示异常，称为参数化的异常，可以用于方法的throws列表中，但是不能用于catch子句中。

（3）编写一个泛型方法，自动将Object类型的对象转换成其他类型。

private static <T> T autoConvert(Object obj)
{
	return (T) obj;
}

（4）当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到了不同的类型，且没有使用返回值，这时候取多个参数中的最大交集类型，例如，下面语句实际对应的类型就是Number了，编译没问题，只是运行时出问题；

比如：定义一个方法，可以将任意类型的数组中的所有元素填充为相应类型的某个对象。

private static <T> void fillArray(T[] a, T obj)
{
	for (int i = 0; i < a.length; i++)
	{
		a[i] = obj;
	}
}

（5）采用自定泛型方法的方式打印出任意参数化类型的集合中的所有内容。

在这种情况下，前面的通配符方案要比范型方法更有效，当一个类型变量用来表达两个参数之间或者参数和返回值之间的关系时，即同一个类型变量在方法签名的两处被使用，或者类型变量在方法体代码中也被使用而不是仅在签名的时候使用，才需要使用范型方法。

public static void printCollection(Collection<?> collection)
{
	System.out.println(collection.size());
	for (Object obj : collection)
	{
		System.out.println(obj);
	}
}

public static <T> void printCollection2(Collection<T> collection)
{
	System.out.println(collection.size());
	for (Object obj : collection)
	{
		System.out.println(obj);
	}
}

（6）参数类型的类型推断具有传递性，

比如：定义一个方法，把任意参数类型的集合中的数据安全地复制到相应类型的数组中。

public static <T> void copy1(Collection<T> c, T[] a)
{
}//编译有问题
public static <T> void copy2(T[] dest, T[] src)
{
}//编译没有问题

（7）编写一个泛形方法，接收一个任意数组，并颠倒数组中的所有元素。

public <T> void reverse(T arr[])
{
	int start = 0;
	int end = arr.length - 1;
	while (true)
	{
		if (start >= end)
		{
			break;
		}
		T temp = arr[start];
		arr[start] = arr[end];
		arr[end] = temp;
		start++;
		end--;
	}
}

定义泛型类型

（1）如果类的实例对象中的多处都要用到同一个泛型参数，即这些地方引用的泛型类型要保持同一个实际类型时，这时候就要采用泛型类型的方式进行定义，也就是类级别的泛型，语法格式如下：

public class GenericDao<T> {
	private T field1;
	public void save(T obj){}
	public T getById(int id){}
}

（2）类级别的泛型是根据引用该类名时指定的类型信息来参数化类型变量的，例如，如下两种方式都可以：

GenericDao<String> dao = null;
new genericDao<String>();

注意：

在对泛型类型进行参数化时，类型参数的实例必须是引用类型，不能是基本类型。

当一个变量被声明为泛型时，只能被实例变量、方法和内部类调用，而不能被静态变量和静态方法调用。因为静态成员是被所有参数化的类所共享的，所以静态成员不应该有类级别的类型参数。

反射与泛型

示例代码如下所示：

Method applyMethod = GenericTest.class.getMethod("applyVector", Vector.class);
Type[] types = applyMethod.getGenericParameterTypes();
ParameterizedType pType = (ParameterizedType) types[0];
System.out.println(pType.getRawType());
System.out.println(pType.getActualTypeArguments()[0]);