泛型

前言：先说两个快捷键

1. Ctrl + Shift + R ：查找当前项目中的类

2. Ctrl + Shift + T：查找源码JAR包中的类

一、概述

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

2.泛型擦除：泛型只在编译时期有效，编译后的字节码文件中不存在有泛型信息！下面两个方法不是方法重写

public void save( List<Person> p ){}

public void save( List<Data> d ){}

3.声明泛型集合，集合两端类型必须一致；泛型类型必须是引用类型，不能为基本类型。

二、泛型方法/泛型类/泛型接口/泛型关键字

1.作用：设计公用的类、方法，对公用的业务实现进行抽取；使程序更灵活。

2.泛型方法：

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

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

    }
}

3.泛型类：

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

    public void update(T t) {

    }

    // 测试方法
    @Test
    public void testSave() {
        // 泛型类： 在创建泛型类对象的时候，确定类型
        GenericDemo<String> demo = new GenericDemo<String>();
        demo.save("test", 1);
    }
}

4.泛型接口

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> {

5.泛型关键字

泛型中：

　　?                  指定只是接收值

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

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

1）关键字：？

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("");// 报错
    }
}

2）关键字：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);//报错
    }
}

3）关键字：super

public class App_extends_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(list1);
        save(list2);
        // save(list3);//报错
    }
}

三、泛型的反射

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

1.反射泛型涉及的API：

Type：Type 是 Java 编程语言中所有类型的公共高级接口。它们包括原始类型、参数化类型、数组类型、类型变量和基本类型。

例如：

List<String>  list   =  new   ArrayList<String>();

泛型集合：list

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

参数化类型（ParameterizedType）：ArrayList<String>为参数化类型

2.反射泛型案例

public class AdminDao extends BaseDao<Admin> {}
public class AccountDao extends BaseDao<Account> {}




/**
 * 所有dao的公用的方法，都在这里实现
 * @author 
 *
 */
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);
        }
    }
}