Java泛型详解

###Java泛型
泛型是很多语言都有得特性，泛型让代码更加的泛化，增加代码的通用性。但是java的泛型并不是1.0引入的，而是jdk5才引入的。为了向上兼容以前的老代码，java的泛型并不像C++，或别的语言的泛型那样强大，java的泛型是利用“擦除”实现的。**泛型的类型信息仅存在与编译期，编译器结束后，就找不到任何使用泛型的痕迹了。**其原理是
在大多数使用泛型的地方，编译器进行了类型检查和插入转型代码。
Java泛型虽没有像C++泛型那么强大，但是还是有它的用武之地的。
Java几乎所有的容器都用到了泛型，泛型能在利用编译器进行类型检查和强制转换。使程序运行其来更安全，代码看上去跟简洁，泛型性还能提高程序运行效率。
举个例子，现在有个容器类，该类可以容纳任意一种类型的对象。以下提供了泛型和非泛型2个版本。
非泛型利用的是用Object类型接受，然后再进行强制转化。但不仅有可能出现转化异常，而且还需要写些强制转化代码，而利用泛型则避免前者的缺点。其实编译完后2者的字节码是差不多的，原因java的泛型是利用擦除实现的。

class ObjectHolder{
	private Object obj;
	public void set(Object object){
		this.obj = object;
	}
	public Object get(){
		return obj;
	}
}


public class GeneratorHolder<T> {
	private T item;
	public void set(T item){
		this.item = item;
	}
	public T get(){
		return item;
	}
	
	public static void main(String[] args){
		ObjectHolder objholder = new ObjectHolder();
		objholder.set(new String());
		String str = (String) objholder.get();
		//int i = (int) obj.get(); java.lang.ClassCastException:
		GeneratorHolder<Integer> holder = new GeneratorHolder<Integer>();
		holder.set(1);
		int i = holder.get();
	}
}

###泛型类型信息的声明
想类型信息，可以是用大写，字母，或小写字母来表示，<可以有多个元组>，

class Tuple<A,B,a,b,c>{
	public void test(A a,B b){
		
	}
}

###泛型方法
不一定要定义泛型类，可以定义泛型方法，只需将类型信息添加到方法定义的地方就行了。 表示泛型类型

public class GeneratorFunction {
	public <T> T generator(T item){
		return item;
	}
}

###边界
边界，如果使用泛型没有设置其边界的，那么其默认边界就是Object（向上转型），由于java泛型的机制，那些边界为object的方法只能调用Object的方法，如果要想泛型做更多的事，就必须设置其边界。使其转为更具体的类型，从而表现更多的行为。
####上界
<? extends MyClass> 表示继承自myClass这个类的类型。
？号表示某种特定的类型通配符，这个我们后面介绍,这是指定上界常用一种方式，MyClass表示具体的类。下面我通过一个例子了解这个上边界的用法。

class Fruit{
	private static int count=0;
	public String toString(){
		return this.getClass().getSimpleName() + " " +count++;
	}
}

class Apple extends Fruit{
	
}

class Orange extends Fruit{
	
}

class Banana extends Fruit{
	
}

class Pear extends Fruit{
	
}
public class GeneratorBound{
	public static void main(String[] args){
		List<Fruit> list = new ArrayList<Fruit>();
		List<? extends Fruit> list1 = list;
		//list1.add(new Fruit()) //error
		//list1.add(new Apple())// error
		//list1.add(new Object())//error
		Fruit f = list1.get(0);
	}
}

这有个Apple,pear等类的父类是Fruit类，
我们实例化了一个Fruit类型的集合list，又声明了一个引用变量list1,这个集合的类型使用来上面的表达式，表示继承自Fruit的集合，并将其指向list。但是这里list1的add方法，却不能添加Fruit或Fruit的子类，按理来说向上转型，应该是可以添加的，这是为什么呢？原因是java的泛型是由"擦除实现"，编译器在编译期就必须确定这个集合的类型，对于list1来说，由于并不知道Fruit的子类型到底有哪些，所以add方法只能添加null,那这样的类型有什么用呢，

Fruit f = list1.get(0);

list1适合用来取元素。因为向上转型是安全的。

###下界（逆变）

<? super MyClass> 也可以使用类型参数<? super T>，前者表示Myclass的超类，后者表示泛型参数超类。我们还是通过刚才那个例子来看看 ``` public class GeneratorBound{ public static void main(String[] args){ List list = new ArrayList(); List<? super Fruit> list1 = list; list1.add(new Fruit()); list1.add(new Apple()); //list1.add(new Object()); Type mismatch: cannot convert from capture#3-of ? super Fruit to Fruit // Fruit f = list1.get(0); } } ``` list1表示Fruit父类的集合，但是我们确发现list1可以添加Fruit的子类，但却不能添加Fruit的父类，这不是和我们上面的描述矛盾？，因为list1并不知道Fruit的父类有哪些，如果可以添加Fruit或Fruit的父类，将违反静态类型安全。而添加子类向上转型为Fruit，是安全的。和<? extends Fruit>是相反的。所以向集合添加元素可以使用<? super MyClass>，而使用则用 <? extends Fruit>更为方便。造成这些原因都是因为java的泛型是由”擦除“实现的。这也是java泛型不够强大的原因。 ###？（通配符） 表示某个特定类型的非原生类型，例如List表示持有任何类型的非原生List，而List<?>表示某种特定类型的非原生List,在很多情况下2者可以表现出相同的性质。

public class GeneratorBound{
	public static void main(String[] args){
		List<Fruit> list = new ArrayList<Fruit>();
		List<?> list2 = list;
		//list2.add(new Object()); error 不知道是什么类型，所以即使是Object类型也无法添加进容器。
		Object obj = list2.get(0);//取出来向上转型为Object类型
		
	}
}

###注意的问题
不能实例化泛型对象和泛型数组，由于擦除的原因，编译器无法验证T类型的安全性。

public class GeneratorOption<T> {
	public void test(Object arg){
		//if(arg instanceof T){} 
		// T item = new T();
		// T[] args = new T[];
	}
}