泛型

1. 概述

泛型是JDK1.5以后才有的， 可以在编译时期进行类型检查，且可以避免频繁类型转化！

在引入泛型之前，Java类型分为【原始类型】、【复杂类型】，其中复杂类型分为【数组】和【类】。引入泛型后，一个复杂类型

就可以在细分成更多的类型。

例如原先的类型List，现在在细分成List, List等更多的类型。

注意，现在List, List是两种不同的类型，

他们之间没有继承关系，即使String继承了Object。下面的代码是非法的

List<String> ls = new ArrayList<String>();
List<Object> lo = ls;

这样设计的原因在于，根据lo的声明，编译器允许你向lo中添加任意对象（例如Integer），但是此对象是

List，破坏了数据类型的完整性。

在引入泛型之前，要在类中的方法支持多个数据类型，就需要对方法进行重载，在引入泛型后，可以解决此问题

（多态），更进一步可以定义多个参数以及返回值之间的关系。

例如强调内容

public void write(Integer i, Integer[] ia);

public void write(Double d, Double[] da);

的泛型版本为

public void write(T t, T[] ta);

2、掌握的知识：

基本用法、泛型擦除、泛型类/泛型方法/泛型接口、泛型关键字、反射泛型(案例)！

// 运行时期异常
@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);
}

泛型擦除，

泛型只在编译时期有效，编译后的字节码文件中不存在有泛型信息！

/*
* 泛型擦除实例

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>();
}

b. 泛型方法/泛型类/泛型接口

作用：

设计公用的类、方法，对公用的业务实现进行抽取！

使程序更灵活！

泛型方法:

public class GenericDemo {

// 定义泛型方法
public <K,T> T save(T t,K k) {
return null;
}

// 测试方法
@Test
public void testMethod() throws Exception {
// 使用泛型方法:  在使用泛型方法的时候，确定泛型类型
save(1.0f, 1);
}
}

泛型类：

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);
}
}

泛型接口：

/**
* 泛型接口
*
*
* @param <T>
*/
public interface IBaseDao<T> {
void save(T t );
void update(T t );
}

泛型接口类型确定： 实现泛型接口的类也是抽象，那么类型在具体的实现中确定或创建泛型类的时候确定

public class BaseDao implements IBaseDao {

泛型接口类型确定： 在业务实现类中直接确定接口的类型

public class PersonDao implements IBaseDao{

c. 泛型关键字

泛型中：

? 指定只是接收值

extends 元素的类型必须继承自指定的类

super 元素的类型必须是指定的类的父类

关键字 ： ?

/**
* 泛型, 涉及到一些关键字
*
* Ctrl + shift + R   查看当前项目中类
* Ctrl + shift + T   查看源码jar包中的类
*
*
*/
public class App_extends_super {

//只带泛型特征的方法
public void save(List<?> list) {
// 只能获取、迭代list;  不能编辑list
}

@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 【下限】

/**
* 泛型, 涉及到一些关键字
*
* Ctrl + shift + R   查看当前项目中类
* Ctrl + shift + T   查看源码jar包中的类
*
*
*/
public class App_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);
}
}

d. 泛型的反射

案例，设置通用方法，会用到反射泛型！

步骤：

1. 案例分析 / 实现

2. 涉及知识点(jdk api)

3. 优化 / 反射泛型

反射泛型涉及API：

Student 类型的表示

Id name

ParameterizedType 参数化类型的表示

ArrayList();

Type 接口，任何类型默认的接口！

包括： 引用类型、原始类型、参数化类型

List list = new ArrayList();

泛型集合： list

集合元素定义：new ArrayList(); 中的String

参数化类型： ParameterizedType

即：“ArrayList ” 为参数化类型

反射泛型案例

public class AdminDao extends BaseDao {} public class

AccountDao extends BaseDao {}

/**
* 所有dao的公用的方法，都在这里实现
*
*
*/
public class BaseDao<T>{

// 保存当前运行类的参数化类型中的实际的类型
private Class clazz;
// 表名
private String tableName;

// 构造函数： 1. 获取当前运行类的参数化类型； 2. 获取参数化类型中实际类型的定义(class)
public BaseDao(){
//  this  表示当前运行类  (AccountDao/AdminDao)
//  this.getClass()  当前运行类的字节码(AccountDao.class/AdminDao.class)
//  this.getClass().getGenericSuperclass();  当前运行类的父类，即为BaseDao<Account>
//                                           其实就是“参数化类型”， ParameterizedType
Type type = this.getClass().getGenericSuperclass();
// 强制转换为“参数化类型”  【BaseDao<Account>】
ParameterizedType pt = (ParameterizedType) type;
// 获取参数化类型中，实际类型的定义  【new Type[]{Account.class}】
Type types[] =  pt.getActualTypeArguments();
// 获取数据的第一个元素：Accout.class
clazz = (Class) types[0];
// 表名  (与类名一样，只要获取类名就可以)
tableName = clazz.getSimpleName();
}

/**
* 主键查询
* @param id    主键值
* @return      返回封装后的对象
*/
public T findById(int id){
/*
* 1. 知道封装的对象的类型
* 2. 表名【表名与对象名称一样， 且主键都为id】
*
* 即，
*    ---》得到当前运行类继承的父类  BaseDao<Account>
*   ----》 得到Account.class
*/

String sql = "select * from " + tableName + " where id=? ";
try {
return JdbcUtils.getQuerrRunner().query(sql, new BeanHandler<T>(clazz), id);
} catch (SQLException e) {
throw new RuntimeException(e);
}
}

/**
* 查询全部
* @return
*/
public List<T> getAll(){
String sql = "select * from " + tableName ;
try {
return JdbcUtils.getQuerrRunner().query(sql, new BeanListHandler<T>(clazz));
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
}