赵雅智_Java 泛型
JDK5以前，对象保存到集合中就会失去其特性，取出时通常要程序员手工进行类型的强制转换，这样不可避免就会引发程序的一些安全性问题。
泛形的典型应用：BaseDao
例如：
public class Demo1 {
/**
* @param args
*/
@Test
public void test(){
ArrayList list = new ArrayList();
list.add("abc");
list.add(new Integer(10));
//list.add("name");
list.add(new Random());
list.add(new ArrayList());
for(int i=0;i<list.size();i++){
Integer num = (Integer) list.get(i); //运行时会出错，但编码时发现不了
System.out.println(num);
}
}
使用泛型，对list集合中存放的对象加了限制，此时再放入其他的对象就出现了错误
@Test
public void testt(){
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(new Integer(10));
/*在list中放入非Integer类型讲提示错误
* list.add("name");
list.add(new Random());
list.add(new ArrayList());*/
for(int i=0;i<list.size();i++){
Integer num = list.get(i); //不用强转
System.out.println(num);
}
}
泛型的作用
- JDK5中的泛形允许程序员在编写集合代码时，就限制集合的处理类型，从而把原来程序运行时可能发生问题，转变为编译时的问题，以此提高程序的可读性和稳定性(尤其在大型程序中更为突出)。
- 不用强转
- 注意：泛型是提供给javac编译器使用的，它用于限定集合的输入类型，让编译器在源代码级别上，即挡住向集合中插入非法数据。但编译器编译完带有泛形的java程序后，生成的class文件中将不再带有泛形信息，以此使程序运行效率不受到影响，这个过程称之为“擦除”。
泛形的基本术语
以ArrayList<E>为例：
- <>念着type of
- E称为类型参数变量
- 整个称为ArrayList<E>泛型类型
- ArrayList<Integer>中的Integer称为实际类型参数
- 整个ArrayList<Integer>称为参数化的类型ParameterizedType
泛型典型应用
- 使用迭代器迭代泛形集合中的元素。
public void test1(){ List<String> list=new ArrayList<String>(); list.add("abc"); list.add("1"); list.add("efg"); //1. Iterator<String> it=list.iterator(); while(it.hasNext()){ String str=it.next(); System.out.println(str); } }
- 使用增强for循环迭代泛形集合中的元素。
@Test public void test1(){ List<String> list=new ArrayList<String>(); list.add("abc"); list.add("1"); list.add("efg"); //2. for(String str:list){ System.out.println(str); } }
- 存取HashMap中的元素。
@Test //未加泛型 public void test2(){ Map m=new HashMap(); m.put(1,"aa"); m.put(2,"bb"); m.put(3,"cc"); //map.keySet(); map.entrySet(); Set set=m.entrySet(); Iterator it=set.iterator(); while(it.hasNext()){ Map.Entry me=(Map.Entry)it.next(); System.out.println(me.getKey()+"..."+me.getValue()); } } @Test //加泛型 public void test3(){ Map<Integer,String> map=new HashMap<Integer,String>(); map.put(1,"aa"); map.put(2,"bb"); map.put(3,"cc"); Set<Map.Entry<Integer,String>> set= map.entrySet(); Iterator<Map.Entry<Integer,String>> it=set.iterator(); while(it.hasNext()){ Map.Entry<Integer,String> me=it.next(); System.out.println(me.getKey()+"..."+me.getValue()); } }
使用泛形时的几个常见问题：
- 使用泛形时，泛形类型须为引用类型，不能是基本数据类型
ArrayList<String> list = new ArrayList<Object>(); //错
ArrayList<Object> list = new ArrayList<String>(); //错
ArrayList<String> list = new ArrayList (); //行
ArrayList list = new ArrayList<String>(); //行 - 两边的类型必须一致
ArrayList<String> list = new ArrayList<String>(); - 两边只有一边用泛型(为了保持兼容性)
ArrayList<String> list = new ArrayList ();
ArrayList list = new ArrayList<String>();public static void test4(ArrayList list){ } public static void test5(ArrayList<String> list){ } public static void main(String[] args) { test5(new ArrayList()); }
自定义泛形——泛型方法
Java程序中的普通方法、构造方法和静态方法中都可以使用泛型。
方法使用泛形前，必须对泛形进行声明，
语法：
<T> ，T可以是任意字母，但通常必须要大写。
- <T>通常需放在方法的返回值声明之前。public static <T> void method(T t);
注意- 只有对象类型才能作为泛型方法的实际参数。
- 在泛型中可以同时有多个类型，
package com.hbsi.generics; import java.util.Arrays; public class Demo3 { /** * @param args */ public static void main(String[] args) { Integer arr1[]={1,2,3,4}; test(arr1,0,3); /*for循环遍历 * for(Integer i:arr1){ System.out.print(i); }//4231*/ //测试Test System.out.println(Arrays.asList(arr1)); //测试Text2 String arr[]={"a","b","c","d"}; test2(arr); System.out.println(Arrays.asList(arr)); } //编写一个泛形方法，实现数组元素的交换。 public static <T> void test(T arr[],int i,int j){ T temp=arr[i]; arr[i]=arr[j]; arr[j]=temp; } //编写一个泛形方法，接收一个任意数组，并颠倒数组中的所有元素 public static <T> void test2(T arr[]){ int start=0; int end=arr.length-1; while(true){ if(start>=end){ break; } T temp=arr[start]; arr[start]=arr[end]; arr[end]=temp; start++; end--; } } }
- 如果一个类多处都要用到同一个泛型，这时可以把泛形定义在类上（即类级别的泛型），语法格式如下：
public class GenericDao<T> {
private T field1;
public void save(T obj){}
public T getId(int id){}
}
注意- 在类级别上定义的泛型,只对类的非静态成员有效
- 静态方法不能使用类定义的泛形，而应单独定义泛形。
package com.hbsi.generics; public class Demo2 <T,E>{ /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub } //自定义泛型方法 public void test1(T t){ } public void test2(T t){ } public static <T> void test3(T t){ } }
通配符
定义一个方法，接收一个集合，并打印出集合中的所有元素，如下所示：
void print (Collection<String> c) {
for (String e : c) {
System.out.println(e);
}
}
问题：该方法只能打印保存了String对象的集合，不能打印其它集合。通配符用于解决此类问题，
方法的定义可改写为如下形式：
void print (Collection<?> c) { //Collection<?>(发音为:"collection of unknown")
for (Object e : c) {
System.out.println(e);
}
}
此种形式下需要注意的是：
由于print方法c参数的类型为Collection<?>，即表示一种不确定的类型
因此在方法体内不能调用与类型相关的方法，例如add()方法。但可以调用与类型无关的方法，例如size()方法
总结：使用?通配符主要用于引用对象，使用了?通配符，就只能调对象与类型无关的方法，不能调用对象与类型有关的方法。
有限制的通配符
限定通配符的上边界(?的类型必须是Number的子类)，限定通配符总是包括自己。
正确：Vector<? extends Number> x = new Vector<Integer>();
错误：Vector<? extends Number> x = new Vector<String>();
限定通配符的下边界(?的类型必须是Integer的父类)
正确：Vector<? super Integer> x = new Vector<Number>();
错误：Vector<? super Integer> x = new Vector<Byte>();