泛型的概念
- 所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返 回值及参数类型。这个类型参数将在使用时（例如，继承或实现这个接口，用这个类型声明变量、 创建对象时确定（即传入实际的类型参数，也称为类型实参）。
- 从
Java 5以后，Java引入了“参数化类型（Parameterized type）”的概念，允许我们在创建集合时再指定集合元素的类型，正如：List<String>，这表明该List只能保存字符串类型的对象。 -
Java 5改写了集合框架中的全部接口和类，为这些接口、类增加了泛型支持，从而可以在声明集合变量、创建集合对象时传入类型实参。
泛型的引入背景
集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在Java 5之前只能把元素类型设计为Object，Java 5之后使用泛型来解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个参数，这个类型参数叫做泛型。Collection<E>，List<E>，ArrayList<E> 这个<E>就是类型参数，即泛型。
引入泛型的目的
- 解决元素存储的安全性问题，好比商品、药品标签，不会弄错。
- 解决获取数据元素时，需要类型强制转换的问题，好比不用每回拿商品、药品都要辨别。
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);
需要注意的点
-
泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。比如
<E1,E2,E3> -
泛型类的构造器如下：
public GenericClass(){}而下面是错误的：
public GenericClass<E>{} -
实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致。
-
泛型不同的引用不能相互赋值。
尽管在编译时 ArrayList<String>和ArrayList<Integer>是两种类型，但是，在运行时只有一个ArrayList被加载到JVM中。
-
泛型如果不指定，将被擦除，泛型对应的类型均按照
Object处理，但不等价于Object。建议：泛型要使用就都用。要不用，就都不要用。
-
如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象。
-
JDK 7.0，泛型的简化操作：
ArrayList<Fruit>first= new ArrayList<>();（类型推断） -
泛型的指定中不能使用基本数据类型，可以使用包装类替换。
-
在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型。
-
异常类不能是泛型的。
-
如果
Person类是Student类的父类，那么List<Person>和List<Student>不具备子父类的关系，二者属于并列关系。但是Person<String>是Student<String>的父类 -
不能使用new E[]。但是可以：E[] elements= (E[])new Object[capacity];
参考：ArrayList源码中声明：Object[] elementData，而非泛型参数类型数组。
-
父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型：
- 子类不保留父类的泛型：按需实现
- 没有类型---擦除
- 具体类型
- 子类保留父类的泛型：泛型子类
- 全部保留
- 部分保留
- 结论：子类除了指定或保留父类的泛型，还可以增加自己的泛型
- 子类不保留父类的泛型：按需实现
代码示例：
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>{
}
网友评论