泛型的概念

• 所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返 回值及参数类型。这个类型参数将在使用时（例如，继承或实现这个接口，用这个类型声明变量、 创建对象时确定（即传入实际的类型参数，也称为类型实参）。
• 从Java 5以后，Java引入了“参数化类型（Parameterized type）”的概念，允许我们在创建集合时再指定集合元素的类型，正如：List<String>，这表明该List只能保存字符串类型的对象。
• Java 5改写了集合框架中的全部接口和类，为这些接口、类增加了泛型支持，从而可以在声明集合变量、创建集合对象时传入类型实参。

泛型的引入背景

集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在Java 5之前只能把元素类型设计为Object，Java 5之后使用泛型来解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个参数，这个类型参数叫做泛型。Collection<E>，List<E>，ArrayList<E> 这个<E>就是类型参数，即泛型。

引入泛型的目的

1. 解决元素存储的安全性问题，好比商品、药品标签，不会弄错。
2. 解决获取数据元素时，需要类型强制转换的问题，好比不用每回拿商品、药品都要辨别。

Java泛型可以保证如果程序在编译时没有发岀警告，运行时就不会产生ClassCastException异常。同时，代码更加简洁、健壮。

泛型类

先看一个只能持有单个对象的类：

class Student {}
// 操作student表
public class Dao {// 表的共性操作，简单的增删改查
    // 添加一条记录
    public void add(Student s){}
}

如果这时候需要操作teacher表，同样需要添加一条记录，那么这个时候就需要重新编写Dao类，这个类的可复用性就不高，如果有很多表需要进行这样的操作，那么我们就需要为每一张表都单独编写一个新的Dao类。

在Java 5之前，要解决这个问题，我们可以使用Object：

public class Dao {// 表的共性操作，简单的增删改查
    // 添加一条记录
    public void add(Object obj){}
}

这样又有了新问题，如果我现在向student表插入一条Teacher的信息，这也是可行了，并且不会报错，因为Object类是所有类的父类。演示一下：

class Student { }

class Teacher { }

public class Dao { // 操作学生表的Dao
    List<Object> stuList = new ArrayList<>();
    // 向数据源中插入一条信息
    public void add(Object obj) {

        stuList.add(obj);
    }

    // 从数据源中取出数据
    public Object get(int index) {
        return stuList.get(index);
    }

    // 方便起见，直接在Dao类中写单元测试方法，实际开发中不要这么写
    @Test
    public void test() {
        Dao stuDao = new Dao();
        Student stu = new Student();
        stuDao.add(stu); // 插入学生信息

        Teacher teacher = new Teacher();
        stuDao.add(teacher); // 没有报错，同样可以插入
        stuDao.add("垃圾数据"); // 同样没有报错，这个问题就比较严重了，什么类型的数据都能插入

        // 取出数据
        Student student = (Student) stuDao.get(0); // 需要强制类型转换
        Teacher teacher1 = (Teacher) stuDao.get(1); // 说出来你可能不信，我从学生表中取出了一个老师，混入了一个？？？
        String str = (String) stuDao.get(2); // 我还从学生表里取出了一个字符串？？

        System.out.println(student);
        System.out.println(teacher1);
        System.out.println(str);
    }
}

我通过Dao这个类操作数据源中的student表，然后分别向其中插入了Student、Teacher、String三种类型的数据，这明显是不符合要求的，student表中的数据都被污染了，这对数据来说，是不安全的，没有类型限制，我们很难保证永远不会写错，泛型的目的之一就是用来约定集合要存储什么类型的对象，并通过编译器确保条件满足。

与其使用Object，我们更希望先指定一个类型占位符，稍后再决定具体使用什么类型。要达到这个目的，需要使用类型参数，用尖括号括住，放在类名后面。然后在使用这个类时，再用实际的类型替换此类型参数。

T、K、V都可以表示类型参数，任意字母都可以。类型常用T表示，是Type的简写，Key和Value常用K和V表示。

现在将上面的Dao修改一下，T 表示类型参数（只能是对象类型，基本数据类型不行）：

public class Dao<T> {
    List<T> list = new ArrayList<>();
    public void add(T t) {
        list.add(t);
    }

    public T get(int index) {
        return list.get(index);
    }
    
    @Test
    public void test1() {
        Dao<Student> stuDao = new Dao<>(); //在创建对象时，指定参数类型
        Student stu = new Student();
        stuDao.add(stu); // 插入学生信息

        //Teacher teacher = new Teacher();
        //stuDao.add(teacher); // 报错 会主动进行类型校验
        //stuDao.add("垃圾数据"); // 报错 
        
        Student student = stuDao.get(0); // 无需进行类型转换
    }
}

创建Dao对象时，必须指明T的类型，就像例子中T的类型为Student，然后，只能在Dao中存储该类型（或其子类，因为多态和泛型不冲突）的对象了。当你调用get(int index)取值时，直接就是正确的类型。

Java泛型的核心概念：你只需要告诉编译器要使用什么类型，剩下的细节交给它来处理。

在Java 5中，创建Dao对象时，你必须这么写：

Dao<Student> stuDao = new Dao<Student>();

但是在Java 7及之后的版本，就可以这么写：

Dao<Student> stuDao = new Dao<>(); //类型推断

泛型接口

定义一个泛型接口：

public interface Dao<T> { // 与泛型类相似，在类名后面添加<T>，参数类型

    void add(T t);

    T get(int index);

}

实现类：

class Student {

}

public class StudentDaoImpl implements Dao<Student> {

    List<Student> stuList = new ArrayList<>();
    @Override
    public void add(Student student) {
        stuList.add(student);
    }

    @Override
    public Student get(int index) {
        return stuList.get(index);
    }

    @Test
    public void test() {
        StudentDaoImpl studentDao = new StudentDaoImpl();
        Student stu = new Student();

        studentDao.add(stu);
        Student student = studentDao.get(0);

        System.out.println(student);

    }
}

如果Teacher有类似的操作，那么Dao这个接口就可以直接被复用：

public class TeacherDaoImpl implements Dao<Teacher> {
    List<Teacher> teacherList = new ArrayList<>();
    @Override
    public void add(Teacher teacher) {
        teacherList.add(teacher);
    }

    @Override
    public Teacher get(int index) {
        return teacherList.get(index);
    }
}

泛型方法

类本身可能是泛型的，也可能不是，和它的方法是否是泛型的没有关系，泛型方法是独立于类的。如果方法是static的，则无法访问该类的泛型类型参数，因此，如果使用了泛型类型参数，则它必须是泛型方法。

要定义泛型方法，请将泛型类型参数放在返回值之前，如下所示：

public class GenericMethods {
    public <T> void f(T x) { // 泛型方法
        System.out.println(x.getClass().getName());
    }

    public static void main(String[] args) {
        GenericMethods gm = new GenericMethods();
        gm.f("");
        gm.f(1);
        gm.f(1.0);
        gm.f(1.0F);
        gm.f('c');
        gm.f(gm);
    }
}

尽管可以同时对类及其方法进行参数化，但这里未将GenericMethods类参数化。只有方法 f() 具有类型参数，该参数由方法返回类型之前的参数列表指示。

对于泛型类，必须在实例化该类时指定类型参数。使用泛型方法时，通常不需要指定参数类型，因为编译器会找出这些类型。 这称为 类型参数推断。因此，对 f() 的调用看起来像普通的方法调用，并且 f() 看起来像被重载了无数次一样。它甚至能接受GenericMethods类型的参数。

如果使用基本类型调用 f() ，自动装箱就开始起作用，自动将基本类型包装在它们对应的包装类型中。

下面的这两种都不是泛型方法：

// 这不是泛型方法，泛型方法的返回值前一定要有<T>
public void add(T t);
// 这个也不是泛型方法
public T get(int index);

需要注意的点

1. 泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。比如<E1,E2,E3>

2. 泛型类的构造器如下： public GenericClass(){}

   而下面是错误的： public GenericClass<E>{}

3. 实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致。

4. 泛型不同的引用不能相互赋值。

   尽管在编译时 ArrayList<String>和ArrayList<Integer>是两种类型，但是，在运行时只有一个ArrayList被加载到JVM中。

5. 泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价于Object。

   建议：泛型要使用就都用。要不用，就都不要用。

6. 如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象。

7. JDK 7.0，泛型的简化操作： ArrayList<Fruit>first= new ArrayList<>();（类型推断）

8. 泛型的指定中不能使用基本数据类型，可以使用包装类替换。

9. 在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型。

10. 异常类不能是泛型的。

11. 如果Person类是Student类的父类，那么List<Person>和List<Student>不具备子父类的关系，二者属于并列关系。但是Person<String>是Student<String>的父类

12. 不能使用new E[]。但是可以：E[] elements= (E[])new Object[capacity];

    参考：ArrayList源码中声明：Object[] elementData，而非泛型参数类型数组。

13. 父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型：

    • 子类不保留父类的泛型：按需实现
      • 没有类型---擦除
      • 具体类型
    • 子类保留父类的泛型：泛型子类
      • 全部保留
      • 部分保留
    • 结论：子类除了指定或保留父类的泛型，还可以增加自己的泛型

代码示例：

class Father<T1, T2> {
}

/**
 * 定义泛型子类Son
 * 情况一：继承泛型父类后不保留父类的泛型
 */
//1.没有指明类型  擦除
class Son1<A, B> extends Father {//等价于class Son1 extends Father<Object,Odject>{}
}

//2.指定具体类型
class Son2<A, B> extends Father<Integer, String> {
}

/**
 * 定义泛型子类Son
 * 情况二：继承泛型父类后保留泛型类型
 */
//1.全部保留
class Son3<T1, T2, A, B> extends Father<T1, T2> {
}

//2.部分保留
class Son4<T2, A, B> extends Father<Integer,T2>{
}