概述
泛型是JDK1.5以后才有的, 可以在编译时期进行类型检查,且可以避免频繁类型转化!
// 运行时期异常
@Test
public void testGeneric() throws Exception {
// 集合的声明
List list = new ArrayList();
list.add("China");
list.add(1);
// 集合的使用
String str = (String) list.get(1);
}
// 使用泛型
@Test
public void testGeneric2() throws Exception {
// 声明泛型集合的时候指定元素的类型
List<String> list = new ArrayList<String>();
list.add("China");
// list.add(1);// 编译时期报错
String str = list.get(1);
}
泛型擦除
泛型只在编译时期有效,编译后的字节码文件中不存在有泛型信息!(所有的类型参数都会被强制转化成Object)
* 泛型擦除实例
public void save(List<Person> p){
}
public void save(List<Dept> d){ // 报错: 与上面方法编译后一样
}
泛型写法
@Test
public void testGeneric3() throws Exception {
// 声明泛型集合,集合两端类型必须一致
List<Object> list = new ArrayList<Object>();
List<String> list1 = new ArrayList<String>();
List list2 = new ArrayList<String>();
List<Integer> list3 = new ArrayList();
// 错误
//List<Object> list4 = new ArrayList<String>();
// 错误: 泛型类型必须是引用类型,不能为基本类型
List<int> list5 = new ArrayList<int>();
}
泛型方法,泛型类 泛型接口
作用:
设计公用的类、方法,对公用的业务实现进行抽取!
使程序更灵活!
泛型方法
public class GenericDemo {
// 定义泛型方法
public <K,T> T save(T t,K k) {
return null;
}
// 测试方法
@Test
public void testMethod() throws Exception {
// 使用泛型方法: 在使用泛型方法的时候,确定泛型类型
save(1.0f, 1);
}
}
泛型类
这里的T是参数类型,是声明方式
public class GenericDemo<T> {
// 定义泛型方法
public <K> T save(T t,K k) {
return null;
}
public void update(T t) {
}
// 测试方法
@Test
public void testMethod() throws Exception {
// 泛型类: 在创建爱泛型类对象的时候,确定类型
GenericDemo<String> demo = new GenericDemo<String>();
demo.save("test", 1);
}
}
泛型接口
/**
* 泛型接口
* @author Jie.Yuan
*
* @param <T>
*/
public interface IBaseDao<T> {
void save(T t );
void update(T t );
}
泛型接口类型确定: 实现泛型接口的类也是抽象,那么类型在具体的实现中确定或创建泛型类的时候确定
public class BaseDao<T> implements IBaseDao<T> {
泛型接口类型确定: 在业务实现类中直接确定接口的类型
public class PersonDao implements IBaseDao<Person>{
泛型关键字
泛型中:
? 指定只是接收值
extends 元素的类型必须继承自指定的类
super 元素的类型必须是指定的类的父类
?的使用
使用?什么的泛型只能作为形参,不能编辑(是只读的)
一般在方法参数中用(参数只读)
public class App_extends_super {
//只带泛型特征的方法
public void save(List<?> list) {
// 只能获取、迭代list; 不能add
}
@Test
public void testGeneric() throws Exception {
// ? 可以接收任何泛型集合, 但是不能编辑集合值;
List<?> list = new ArrayList<String>();
//list.add("");// 报错
}
}
extends限定了父类
public class App_extends_super {
/**
* list集合只能处理 Double/Float/Integer等类型
* 限定元素范围:元素的类型要继承自Number类 (上限)
* @param list
*/
public void save(List<? extends Number> list) {
}
@Test
public void testGeneric() throws Exception {
List<Double> list_1 = new ArrayList<Double>();
List<Float> list_2 = new ArrayList<Float>();
List<Integer> list_3 = new ArrayList<Integer>();
List<String> list_4 = new ArrayList<String>();
// 调用
save(list_1);
save(list_2);
save(list_3);
//save(list_4);
}
}
super 必须是指定类型的父类
/**
* super限定元素范围:必须是String父类 【下限】
* @param list
*/
public void save(List<? super String> list) {
}
@Test
public void testGeneric() throws Exception {
// 调用上面方法,必须传入String的父类
List<Object> list1 = new ArrayList<Object>();
List<String> list2 = new ArrayList<String>();
List<Integer> list3 = new ArrayList<Integer>();
//save(list3);
}
}
泛型反射
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
/**
*
* @author GeGuo
* 在该类中获取 T的类型
* @param <T>
*/
public class BaseGeniric<T> {
public BaseGeniric(){
//获取当前运行的父类
Type type = this.getClass().getGenericSuperclass();
//强转成参数化类型
ParameterizedType pt = (ParameterizedType) type;
//获取参数化类型中的实际类型
Type[] cs = pt.getActualTypeArguments();
//取出第1个类型:因为只有一个T
Class clazz = (Class) cs[0];
System.out.println("T name:"+clazz.getSimpleName());
// clazz.newInstance();
// clazz.getName();
// clazz.getDeclaredFields()
}