java 泛型

java 的泛型就是c++中的模板类。目的就是解类型装换所花费的编程时间，使一种程序适配更多的类型

为什么要用泛型

   public class ArraryList{
        private Object[];
        public Object get(int i){}
        public void add(Object o){}
    }

上面是一个非常简单的数组类，get每次返回的是Object，我们一般都要转换成存入的类型。

		ArrayList arraylist=ArrayList();
		String string=(String)arraylist.get(0);
		arraylist.add(new File("...."));

如上面所示，不同类型的去除转换时非常麻烦的，而且还不安全。所以java 引入了类型参数（type parameter）来完成泛型编写解决此问题

定义泛型类

以下是一个见到那的泛型类

public class Pair<T>{
	private T first;
	private T second;
	
	public Pair() {
		this.first=null;
		this.second=null;
	}

	public Pair(T first, T second) {
		super();
		this.first = first;
		this.second = second;
	}

	public T getFirst() {
		return first;
	}

	public void setFirst(T first) {
		this.first = first;
	}

	public T getSecond() {
		return second;
	}

	public void setSecond(T second) {
		this.second = second;
	}
	
}

我们可以使用

Pair<String> p= new Pair()

通配符（wildcard type）

定义泛型函数

public class ArrayAlg {
	public static<T> T getWiddle(T...a)
	{
		return a[a.length/2];
	}

}

定义符号<T>要放在修饰符（public static）之后 返回类型T之前

		
	String middle=ArrayAlg<String>.getMiddle("123","Q","public")
	String middle=ArrayAlg.getMiddle("123","Q","public")
	String middle=ArrayAlg.getMiddle(3.14,0,1)
		

注意第三种方法会保持，因为传入了一个double 和两个intger，编译器不知道转换成那个

变量类型的限定

public class ArrayAlg {
	public static<T extemds Comparable>T min(T[] a){
		if (a==null|| a.length==0)
		return null;
		T smllest=a[0];
		for(int i=1;i<a.length;i++)
			if(smllest.compareTo(a[i])>0)smallest=a[i];
		return smallest;
	}	
}

<T extemds Comparable> 可以防止smallest 没有compareTo方法。

泛型代码和虚拟机

对于虚拟机来说不存在泛型代码。虚拟即会把泛型代码变不同类。虚拟机会擦除类型变量，替换成限定类型（没有限定使用Object）

public class Pair {
	private Object first;
	private Object  second;
	
	public Pair() {
		this.first=null;
		this.second=null;
	}

	public Pair(Object  first, Object  second) {
		super();
		this.first = first;
		this.second = second;
	}

	public Object  getFirst() {
		return first;
	}

	public void setFirst(Object  first) {
		this.first = first;
	}

	public Object  getSecond() {
		return second;
	}

	public void setSecond(Object  second) {
		this.second = second;
	}
	
}

约束和局限性

不能用基本类型实例话类型参数

不饿能使用

Pair<double>
Pair<Double>

Double的可以，因为类型擦除之后时接受Object类型的参数，而基本类型如double是不能赋值给Object的

##运行时类型查询只适用原始类型

if(a instanceof Pair<String>)
if(a instanceof Pair<T>)	

类型餐厨之后，都是一样的

Pair<String> stringPair=;
Pair<Eployee> employeePair=;
if(StringPair.getClass())==employeePair.getClass())

类型擦胡之后都是一样的

。。。。未完待续

泛型类型的继承关系

Parent 和Children是子类关系，但是Pair<Parent>和<\Children>没有任何关系

统配符类型

<Children>是<? extends Parent>的子类
<？extends Children>所有children的超类

<?>等价于 <? extends Object>