java拾遗之泛型

一、 泛型概述

泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？

顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

泛型只在编译阶段有效，在编译之后程序会采取去泛型化的措施。也就是说Java中的泛型，只在编译阶段有效。在编译过程中，正确检验泛型结果后，会将泛型的相关信息擦出，并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法。也就是说，泛型信息不会进入到运行时阶段。

二、 泛型的使用

泛型有三种使用方式，分别为：泛型类、泛型接口、泛型方法。

1. 泛型类

泛型类的使用还是比较广泛的，最常见的场景就是集合。例如，List。

下面是一个简单的泛型类

class User<T>{
    //泛型类中只能定义泛型类型的数据，不能实例化。
    private T t;
    //泛型类型可以出现在参数中
    public void setT(T t){
        this.t = t;
    }
    //泛型类型可以出现在返回值上
    public T getT(){
        return t;
    }
}

注：

• 泛型的类型参数只能是类类型，不能是简单类型。

• 不能对确切的泛型类型使用instanceof操作。

• public class Student extends Person<String>{}   //这个需要注意，Student不是泛型类，但是父类是泛型类
  

• public class Student extends Person<T>{}    //这么写是不对的
  

• public class Student<E> extends Person<String>{}   //这个也是对的
  

2. 泛型接口

泛型接口和泛型类的使用方式基本相同。

定义一个泛型接口

//定义一个泛型接口
public interface Generator<T> {
    public T next();
}

当实现泛型接口的类，未传入泛型实参时：

/**
 * 未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
 * 即：class FruitGenerator<T> implements Generator<T>{}
 * 如果不声明泛型，如：class FruitGenerator implements Generator<T>，编译器会报错："Unknown class"
 */
class FruitGenerator<T> implements Generator<T>{
    @Override
    public T next() {
        return null;
    }
}

当实现泛型接口的类，传入泛型实参时：

/**
 * 传入泛型实参时：
 * 定义一个生产器实现这个接口,虽然我们只创建了一个泛型接口Generator<T>
 * 但是我们可以为T传入无数个实参，形成无数种类型的Generator接口。
 * 在实现类实现泛型接口时，如已将泛型类型传入实参类型，则所有使用泛型的地方都要替换成传入的实参类型
 * 即：Generator<T>，public T next();中的的T都要替换成传入的String类型。
 */
public class FruitGenerator implements Generator<String> {
    private String[] fruits = new String[]{"Apple", "Banana", "Pear"};
    @Override
    public String next() {
        Random rand = new Random();
        return fruits[rand.nextInt(3)];
    }
}

3. 泛型方法

泛型方法，是在调用方法的时候指明泛型的具体类型 。

public  <T> T get(T number){
    System.out.println(number.toString());
    return number;
}

泛型方法和泛型类没有什么关系，泛型方法在被调用时确定。

4. 泛型擦除和补偿

Java的泛型是编译时状态，在编译后泛型就不再存在。编译器会对源码进行检查，如果编码复合泛型要求就会通过。同时，类加载器在加载类之前会将使用泛型的地方进行类型转换。

public void test(){
 final Integer integer = get(8);
}
public  <T> T get(T number){
 System.out.println(number.toString());
 return number;
}

在泛型擦除之后T会被替换为Object

5. 泛型通配符

6. 数组协变

Object[] objects = new Object[10];
objects = new String[10];   //将Object引用指向String，此时数组的存储空间是String的
objects[0] = new Integer(0);  //编译器会警告，但是不会报错，因为编译器不是万能的，它不会在意上一句话是否正确，而只检查当前的语句是否正确。

/**
	此时会报异常：数组存储异常ArrayStoreException
*/

下面我们用集合来模拟上面数组的使用场景

List<Object> list = new ArrayList<String>();   //编译器直接报错
//下面假设没有报错，那么接下来我们想list中添加数据
list.add(new Integer(10));

/**
	我们可以考虑，如果第一步编译器不报错，那么第二步会不会成功呢？
	答案是肯定的。因为虚拟机并没有泛型的概念在执行第二步时已经经历了类型擦除，也就是说第一步相当于List list = new ArrayList();那么第二步当然可以成功了。
**/

我们知道Ingeter是Number的一个子类，List<Integer>与List<Number>实际上是相同的一种基本类型。那么问题来了，在使用List<Number>作为形参的方法中，能否使用List<Integer>的实例传入呢？在逻辑上类似于List<Integer>和List<Number>是否可以看成具有父子关系的泛型类型呢？

public void fun1(){
      List<Integer> list = new ArrayList<Integer>();
      getNumber(list);    //这里会报错，因为类型不匹配
}
public void getNumber(List<Number> list){
        
}

通过提示信息我们可以看到List<Integer>不能被看作为List<Number>的子类。由此可以看出:同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的。

回到上面的例子，如何解决上面的问题？总不能为了定义一个新的方法来处理List<Integer>类型的类，这显然与java中的多态理念相违背。因此我们需要一个在逻辑上可以表示同时是List<Integer>和List<Number>父类的引用类型。由此类型通配符应运而生。

7. 泛型上限和泛型下限

7.1 泛型的上限

7.1.1 为什么需要约束上限

问题：

请写一个方法用来打印集合中的所有元素。

public void print(Collection<? extends Person> list){
    Iterator<? extends Person> iterator = list.iterator();
    while(iterator.hasNext()){
        Person person = iterator.next();
        System.out.println(person.toString());
    }
}

测试：

public void testPrint(){
    //正确
    List<Person> personList = new ArrayList<>();
    List<Student> studentList = new ArrayList<>();
    print(personList);
    print(studentList);
    //错误
    List<Integer> integerList = new ArrayList<>();
    print(integerList);
}

通过上面的例子，我们已经可以回答为什么需要约束上限这个问题了：

在实际开发中我们可能需要灵活的参数传递以达到封装的目的，在不使用泛型时我们可能会采用以下方式：

public void add(Person person){
    
}

Person有多个子类，根据多态性，我们可以将Person的子类作为参数进行传递。依照这个思路，我们可以尝试在泛型中使用多态：

public void testAdd(){
    List<Student> list = new ArrayList<>();
    //编译器报错
    add(list);
}
public void add(List<Person> list){  //相当于List<Person> list = new ArrayList<Student>();
	//加入上面不报错，则可以进行下面的操作,就会发生类型不安全的问题。
    list.add(new Worker());
}

然而，编译器直接报了错，这是为什么呢？

Java中规定泛型在使用时应该保持左右一致性，上面的使用就破环了这一规范。

7.1.2 如何使用

public void print(Collection<? extends Person> list){
    Iterator<? extends Person> iterator = list.iterator();
    while(iterator.hasNext()){
        Person person = iterator.next();
        System.out.println(person.toString());
    }
}

其中<? extends Person>就表示可以传入Person类型及其子类型。

7.1.3 注意

在使用上限约束时只允许读取元素而禁止添加元素

public void print(Collection<? extends Person> list){
    list.add(new Student());    //错误的用法
    Iterator<? extends Person> iterator = list.iterator();
    while(iterator.hasNext()){
        Person person = iterator.next();
        System.out.println(person.toString());
    }
}

为什么上限约束只允许读取呢？

public void testPrint(){
    List<Student> list = new ArrayList<>();
    print(list);
}

public void print(Collection<? extends Person> list){ 
    //开发人员可能会不小心写出下面的代码
    //由于此时编译器并不清楚传入的具体类型，使用list添加Person可能会成功，从而导致类型安全问题，因此直接就不允许操作会更安全。
    list.add(new Person());
}

8. 泛型的下限

8.1 怎么使用

public void set03(List<? super Integer> list){
    String str = (String) list.get(0);
    System.out.println(str);
}

其中<? super Integer>表示可以传入的类型是Integer及其父类型。

8.2 注意

• 使用时，读取元素不会进行自动类型转换，需要自己指定，因为编译器并不知道你要使用的具体类型是什么。

• 可以向其中添加元素

  public void set05(List<? super Student> list){
      list.add(new Student());
  }
  

  这是因为传入的要不然是Student类，要不然就是其父类，不会出现类型安全问题。