泛型你真的了解吗

你需要掌握的：

• 基本用法
• 泛型擦除
• 泛型类/泛型方法/泛型接口
• 泛型关键字
• 反射泛型

---

和泛型的初次见面

泛型是JDK1.5以后才有的， 可以在编译时期进行类型检查，且可以避免频繁类型转化。很明显，使用Java泛型，我们可以省掉强制类型转换。编译器会保留参数的类型信息，执行类型检查，执行类型转换操作。因此开发人员不需要自己确保类型转换的安全性，而把这个交给编译器去做。

基本使用

    public void testGeneric() throws Exception {
        // 声明泛型集合的时候指定元素的类型
        List<String> list = new ArrayList<String>();
        list.add("China");
        //list.add(1);// 编译时期报错
        String str = list.get(1); 
    }

泛型擦除

泛型只在编译时期有效，编译后的字节码文件中无效，怎么理解呢，看demo:

    //泛型擦除实例 
    public void save(List<Person> p){

    }

    public void save(List<Dept> d){    
        // 报错： 与上面方法编译后一样
    }

这并不是方法的重载，这直接会编译时报错。

泛型的几种写法

    // 泛型写法
    @Test
    public void testGeneric2() 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);
    }
}

• 泛型类

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

• 泛型接口

public interface IBaseDao<T> {
    void save(T t );
    void update(T t );
}

//泛型接口类型确定： 实现泛型接口的类也是抽象，那么类型在具体的实现中确定或创建泛型类的时候确定
public class BaseDao<T> implements IBaseDao<T>{
}

//泛型接口类型确定： 在业务实现类中直接确定接口的类型
public class StudentDao implements IBaseDao<Student>{
}

泛型关键字

泛型中：
? 指定只是接收值
extends 元素的类型必须继承自指定的类
super 元素的类型必须是指定的类的父类

• 关键字： ？

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

public void save(List<?> list){
    // 只能获取、迭代list;  不能编辑list
}

@Test
public void testGeneric() throws Exception {
   // ?  可以接收任何泛型集合， 但是不能编辑集合值； 所以一般在方法参数中用
   List<?> list = new ArrayList<String>();
   //list.add(""); //报错
}

• 关键字：extends 【上限】

public void save(List<? extends Number> list) {

    }

    @Test
    public void testGeneric() throws Exception {
        List<Double> list1 = new ArrayList<Double>();
        List<Float> list2 = new ArrayList<Float>();
        List<Integer> list3 = new ArrayList<Integer>();
        List<String> list4 = new ArrayList<String>();

        //调用
        save(list1);
        save(list2);
        save(list3);
        //save(list4);
    }

• 关键字：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);
    }
}

泛型的反射

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

步骤：
    1. 案例分析 /  实现
    2. 涉及知识点(jdk api)
    3. 优化 / 反射泛型

    案例： 
    demo数据库中有两张表：student,admin；
    对应写两个实体类Student、Admin :

//Student实体类
public class Student {
    private int sid;
    private String name;
    private String gender;

    public int getSid() {
        return sid;
    }

    public void setSid(int sid) {
        this.sid = sid;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }
}

//Admin实体类
public class Admin {

    private int id;
    private String userName;
    private String pwd;

    @Override
    public String toString() {
        return "Admin{" +
                "id=" + id +
                ", userName='" + userName + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }
}

//AdminDao.java
public class AdminDao extends BaseDao<Admin> {
}

//StudentDao.java
public class StudentDaoextends BaseDao<Student> {
}

然后两个dao,都有一个findById(int id),与getAll（）方法，仅仅是对应的表名和返回值不同，于是抽象出一个公有的BaseDao。

//两个dao抽象出来的公有dao
public class BaseDao<T> {

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

    //通过构造函数 1.获取当前类的参数化类型 2.获取参数化类型中实际类型的定义
    public BaseDao(){
        //获取当前运行类的父类，即Base<Admin>
        Type type = this.getClass().getGenericSuperclass();
        //强转为参数化类型 [BaseDao<Admin>]
        ParameterizedType pt = (ParameterizedType) type;
        //获取参数化类型中，实际类型的定义
        Type types[] = pt.getActualTypeArguments();
        //获取数据的第一个元素
        clazz = (Class) types[0];
        tableName = clazz.getSimpleName();

        System.out.println("-------" + tableName);

    }

    /**
     * 主键查询
     * @param id
     * @return
     */
    public T findById(int id){
        /**
         * 1.知道封装的对象的类型
         * 2.所有的表名【与对象名称一样，且主键都为id】
         */
        String sql = "select * from " + tableName + " where id = ?";

        try {
            return JdbcUtils.getQueryRunner().query(sql, new BeanHandler<T>(clazz), id);
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    public List<T> getAll( ){
        /**
         * 1.知道封装的对象的类型
         * 2.所有的表名【与对象名称一样，且主键都为id】
         */
        String sql = "select * from " + tableName;

        try {
            return JdbcUtils.getQueryRunner().query(sql, new BeanListHandler<T>(clazz));
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

}

StudentDao、与AdminDao都继承自BaseDao，然后通过一个测试方法拿到数据库中的表。

 @Test
    public void test(){

        AdminDao adminDao = new AdminDao();
        Admin admin = adminDao.findById(2);

        System.out.println(admin);
        System.out.println("-->" + adminDao.getAll());
    }

---

补充：
反射泛型涉及API：
ParameterizedType 参数化类型的表示
Type 接口，任何类型默认的接口！包括： 引用类型、原始类型、参数化类型

上面代码中用到的JdbcUtils是我封装的一个数据库操作类

public class JdbcUtils {

    private static DataSource dataSource;

    static {
        dataSource = new ComboPooledDataSource();
    }

    public static DataSource getDataSource(){
        return dataSource;
    }

    public static QueryRunner getQueryRunner(){
        return new QueryRunner(dataSource);
    }

}

详细的可以看看我的上一篇文章。