Java泛型

1 泛型的概念

“泛型”这个术语的意思是：适用于许多许多的类型。泛型比较常见的用法，是指定容器要持有什么类型的对象，而且由编译器来保证类型的正确性。例如：

List<Integer> list = new ArrayList<Integer>();
Map<Integer, String> map = new HashMap<Integer, String>();

上面的例子是泛型的常见使用方式，这也引出了Java泛型的一个局限性：基本类型无法作为类型参数，如上面的Integer。不过，Java SE5之后，Java具备了自动装箱和拆箱的功能，可以自动实现基本类型和对应包装类型之间的自动转换。拆箱、装箱见博客：http://blog.csdn.net/yy_james/article/details/73253068

2 泛型类

public class Holder<T>{
	private T a;

	public Holder(T a){
		this.a = a;
	}

	public set(T a){
		this.a = a;
	}

	public T get(){
		return a;
	}

	public static void main(String[] args){
		Holder<String> holder = new Holder<String>("String");
	}
}

3 泛型接口

public interface Generator<T>{
	T next();
}

public class Fabonacci implements Generator<Integer>{
	private int count = 0 ;
	public Integer next(){
		return fib(count++);
	}

	private int fib(int i){
		if(i<2) return 1;

		return fib(i-1) + fib(i-2);
	}

	public static void main(Stirng[] args){
		Fabonacci fcc = new Fabonacci();
		for(int i=0; i<18; i++){
			System.out.println(fcc.next());
		}
	}
}

4 泛型方法

泛型方法所在的类可以是普通的类，也可以是泛型的类。使用泛型类时，必须在创建对象的时候指定类型参数，而使用泛型方法时，不必指明类型参数，Java编译器会找出具体的类型，这被称为“类型参数推断”。

public class GenericMethod(){
	public <T> void f(T x){
		System.out.println(x.getClass().getName());
	}

	public static void main(String[] args){
		GenericMethod gm = new GenericMethod();
		gm.f("");
		gm.f(0);
		gm.f(0.1);
		gm.f(0.1F);
		gm.f(gm);
	}
}

需要注意的时，“类型参数推断”只有在赋值的时候有效，其他时候并不起作用。具体原因在于，Java的泛型在运行时会“擦除”。

5 擦除

下面这个例子证明，“在泛型代码内部，无法获得任何有关泛型参数类型的信息”。这也意味着，通过Java 的RTTI和发射机制，无法获得泛型类型。

class Frob{}
class Fnorkle{}
class Quark<Q>{}
class Particle<POSITION,MOMENTUM>{}

public class LostInformation{
	public static void main(Stirng[] args){
		List<Frob> list = new ArrayList<Frob>();
		Map<Frob,Fnorkle> map = new HashMap<Frob,Fnorkle>();
		Quark<Frob> quark = new Quark<Frob>();
		Particle<Long,Double> p = new Particle<Long,Double>();

		System.out.println(Arrays.toString(list.getClass().getTypeParameters()));
		System.out.println(Arrays.toString(map.getClass().getTypeParameters()));
		System.out.println(Arrays.toString(quark.getClass().getTypeParameters()));
		System.out.println(Arrays.toString(p.getClass().getTypeParameters()));
	}
}
/* Output
[E]
[K,V]
[Q]
[POSITION,MOMENTUM]
*///

Java的泛型是使用擦除来实现的，这意味着，当你在使用泛型时，任何具体的类型信息都被擦除了。

泛型的类型只有在静态类型检查期间才出现，在此之后，程序中所有泛型类型都将被擦除，替换为它们的非泛型上界。例如，List<T>会被擦除为List。

Java之所以通过擦除来实现泛型，主要是因为Java1.0时，Java并没有泛型机制，为了保证Java在加入泛型特性之后，基于之前Java版本开发的包还可以正常运行，Java的设计者们选择了擦除这种折中的方案，为Java引入泛型机制。

Java的擦除对于开发者来说是透明的，Java实现了“看起来”和C++中一样的泛型机制，但是内部的类型参数在类型检查之后都被擦除，底层通过编译器来实现。例如：

List<Cat> list = new ArrayList<Cat>();

这段代码对于Java开发者而言，可以认为list中存储的就是Cat对象，但实际上，list中存储的只是Object对象而已。

Java的泛型动作，都发生在边界。对于传递进来的值，由编译器进行额外的编译期检查，对于传递出的值，编译器插入了强制转换类型的代码。