/*
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,静态方法不能定义泛型,因为静态加载时,还不知道有什么对象,造成冲突;
*/