1.泛型的概念
在Java SE 1.5之前,没有泛型的情况的下,通过对类型Object的引用来实现参数的“任意化”,“任意化”带来的缺点是要做显式的强制类型转换,而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况,编译器可能不提示错误,在运行的时候才出现异常,这是一个安全隐患。
泛型的好处是在编译的时候检查类型安全,并且所有的强制转换都是自动和隐式的,提高代码的重用率。
泛型是提供给javac 编译器使用的,可以限定集合的输入类型,让编译器挡住源代码程序中的非法输入,编译器编译带类型说明的集合时会擦除"类型"信息,使程序运行效率不受影响,对于参数化的泛型类型,getClass()方法的返回值和原始类型完全一样, 由于编译器生成的字节码会去掉泛型的类型信息,只要能跳过编译器,就可以往某个泛型集合加入其它类型的数据,例如,用反射得到集合,在调用其add方法就可.
2、JDK1.5引入泛型
package com.itcast.generic;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public class GenericTest1 {
public static void main(String[] args) {
List list = new ArrayList();
list.add(new String());///
list.add("abc");
//运行时会出错,但编码时发现不了---throw java.lang.ClassCastException
Integer num = (Integer) list.get(0);
}
}
3.泛型的简单应用和了解泛型
JDK5中的泛形允许程序员在编写集合代码时,就限制集合的处理类型,从而把原来程序运行时可能发生问题,转变为编译时的问题,以此提高程序的可读性和稳定性(尤其在大型程序中更为突出)。package com.itcast.generic;
import java.util.ArrayList;
import java.util.List;
public class GenericTest2 {
public static void main(String[] args) throws Exception {
//List集合中放入java.lang.Integer类型变量
List<Integer> list = new ArrayList<Integer>();
list.add(50);
//通过字节码文件反射调用add方法加入java.lang.String类型变量
list.getClass().getMethod("add", Object.class).invoke(list, "itcast");
System.out.println(list);///能打印出字符串
}
}
注意 :
参数化类型与原始类型的兼容性
Collection<String> c = new Vector();// 这样是可以的
Collection c = new Vector<String> ();// 这样是可以的
泛型中没有继承的概念
Collection<Object> c = new Vector<String>();//这样不允许,反之也不行
泛型中的? 通配符的扩展
l 限定通配符的上边界
意思是 ?类型必须是 Number(extends后面的类型)类型的子类
Ø Vector<? extends Number> v = new Vector<Integer>();//正确
Ø Vector<? extends Number> v = new Vector<String>(); //错误
l 限定通配符的下边界
意思是 ?类型必须是 Integer(super后面的类型)类型的父类
Ø Vector<? super Integer> v = new Vector<Number>();//正确
Ø Vector<? super Integer> v = new Vector<Byte>();//错误
5.泛型的通配符扩展应用案例
package com.itcast.generic;
import java.util.HashMap;
import java.util.Map;
/**
* 遍历Map集合
* @author Say
*
*/
public class IteratorMap {
public static void main(String[] args) {
Map<String,Integer> map = new HashMap<String, Integer>();
map.put("itcast", 1);
map.put("aaa", 50);
map.put("bbb", 41);
for(Map.Entry<String, Integer> entry:map.entrySet()){
System.out.println(entry.getKey()+"-->"+entry.getValue());
}
}
}
6.自定义泛型方法
泛型方法定义规则:
Java程序中的普通方法、构造方法和静态方法中都可以使用泛型。方法使用泛形前,必须对泛形进行声明,语法:<T>,T可以是任意字母,但通常必须要大写。<T>通常需放在方法的返回值声明之前。
例如:
public static <T> void doxx(T t);
泛型方法定义注意问题:
•只有对象类型才能作为泛型方法的实际参数。
•在泛型中可以同时有多个类型.
例如:
public static <K,V> V getValue(K key) { return map.get(key);}
public static <K extends Annotation> void getXX(){}
public static <K extends Annotation & Cloneable> void getXX(){}
package com.itcast.generic;
/**
* 编写一个泛形方法,实现数组元素的交换。
*/
public class SwapArray {
public static void main(String[] args) {
//对于数组中的int类型不会自动装箱和拆箱
swap(new String[]{"a","bncd","fdsafdsa"}, 2, 0);
swap(new Integer[]{15,25,30,25,47}, 2, 4);
}
public static <T> void swap(T[] arr,int x,int y){
T temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
7.自定义泛型类
如果一个类多处都要用到同一个泛型,这时可以把泛形定义在类上(即类级别的泛型)
语法格式如下:
public class GenericDao<T> {
private T field1;
public void save(T obj){}
public T getId(int id){}
}
注意: 静态方法不能使用类定义的泛形,而应单独定义泛形。先使用类级别的泛型.
8.通过反射获取泛型的实际类型参数
package com.itcast.generic;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Date;
import java.util.List;
/**
* 以泛型方法获取参数类型
*/
public class TypeArgumentsTest {
public static void main(String[] args) throws Exception{
//获取applyList方法对象
Method method = TypeArgumentsTest.class.getMethod("applyList", List.class);
//获取方法上泛型参数
Type[] types=method.getGenericParameterTypes();
ParameterizedType pType = (ParameterizedType) types[0];
//获取原始类型
System.out.println(pType.getRawType());
//获取实际类型参数
System.out.println(pType.getActualTypeArguments()[0]);
}
public static void applyList(List<Date> list){
}
}