Java泛型总结（集合泛型、方法泛型、通配符）

	/*
1，泛型的限定
	*/
	public static void main(String[] args) 
	{
		Class<Number> x=String.class.asSubclass(Number.class);
		Class<?> x=Class<String> y;

		HashMap<String ,Integer> maps = new HashMap<String,Integer>;
		maps.put("zxx",28);
		maps.put("lhm",25);
		maps.put("flx",35);

		Set<Map.Entry<String,Integer>> entrySet = maps.entrySet();
		for (Map.Entry<String,Integer> entry : entrySet)
		{	System.out.println(entry.getKey()+":"+entry.getValue());
		}



		swap(new String[]{"abc","xyz","itcast"},1,2);
		swap(new Integer[]{1,3,5,6,7},2,3);//泛型参数必须为引用类型；
	}
/*2,泛型方法：
泛型类定义的反应,在整个类中有效,如果被方法使用,那么泛型类的对象明确要操作的具体类型后,所有要操作的类型就已经固定了.

为了让不同方法可以操作不同类型,而且类型还不确定,那么可以将泛型定义在方法上.

*/
	private static <T> void swap(T[] a,int i,int j){//在返回类型前写<泛型>，数组也是前写<泛型>
		T tmp = a[i];
		a[i] = a[j];
		a[j] = tmp;
	}

	add(3,5);
	Number x1 = add(3.5,3);//返回是Number类型
	Object x2 = add(3,"abc");//

	private static <T> T add(T x,T y){//在返回类型前写<泛型>
		return x+y;
	}
	/*
3,利用泛型的方法限定，来转换参数类型
	*/
	Object boj="abc";
	String x3 = autoConvert(obj);
	private static <T> T autoConvert(Object obj){
		return (T)obj;
	}
/*
4，简单应用
*/
	private static <T> void fillArray(T[] a,T obj){
		for(int i=0;i<a.length;i++){
			a[i]=obj;
		}
	}
	public static <T> void printCollection(Collection<T> collection,T obj){
		System.out.println(collection.size());
		for (Object obj:collection )
		{	System.out.println(obj);
		}
		collection.add(obj);//用了泛型代替？通配符后，就可引用带参数的方法了；
	}
/*
5,通配符<?>,也可以理解为占位符号
? extends E:可以接受E类型或者E的子类型 上限 <? extends E>
? super E:可以接受E或E的父类型 下限  <? super E>
ArrayList<? extends Object> al = new ArrayList<String>(); al.add("aa");  //错  
   因为集合具体对象中既可存储String,也可以存储Object的其他子类,所以添加具体的类型对象不合适,类型检查会出现安全问题.

*/

//6,泛型的传播
	copy1(new Vector<String>(),new String[10]);//可以
	copy2(new Date[10],new String[10]);//可以
	//copy1(new Vector<Date>(),new String[10]);//错误
	public static <T> void copy1(Collection<T> dest,T[] src){
		
	}	
	public static <T> void copy2(T[] dest,T[] src){
		
	}
}
/*
7,new对象时，两边的泛型兼容性
一边使用泛型，一边使用原始类型时，是可以兼容的；
两边都使用泛型是，泛型参数不具备继承性；
ArrayList<String> al = new ArrayList<Object>();  //错

*/

/*
8,定义泛型类型
如果类的实例对象中的多处都要用到同一个泛型参数,即这些地方引用的泛型类型要保持同一个实际类型时,这时候就要采用泛型类型的方式进行定义,也就是类级别的泛型.
public class GenericDao<T>{
	public void add(T x){}
	public T findById(int id){}
	public void delete(T obj){}
	public void delete(int id){}
	public void update(T obj){}

	public T findByUserName(){} 
	public Set<T> findByConditions(String where){return null}
}
*/
/*
9,静态方法不能定义泛型，因为静态加载时，还不知道有什么对象，造成冲突；
*/