【从零到Offer】- 泛型

泛型是个啥

Java 泛型是 JDK 5 中引入的一个新特性，其提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

通过将数据类型参数化，泛型给JAVA代码带来了不少的便利性。因此泛型也成为了许多框架代码中的常客，如日常使用的ArrayList、LinkedList等，其实都是泛型的延伸造化。为了更好的利用好泛型，我们有必要了解一下泛型的便利之处。

泛型用途

代码复用

在引用泛型之前，针对相似逻辑但不同类型对象的转换逻辑，我们可能需要编写多套代码实现。

public Map<String,Sword> transferSword(List<Sword> list){
    Map<String,Sword> map = new HashMap<>();
    for (Sword v : list) {
        String desc = v.getDesc();
        map.put(desc, v);
    }
    return map;
}
public Map<String,Staff> transferStaff(List<Staff> list){
    Map<String,Staff> map = new HashMap<>();
    for (Staff v : list) {
        String desc = v.getDesc();
        map.put(desc, v);
    }
    return map;
}

通过结合上函数式编程，我们就可以将转换的逻辑抽象出来，不再受限于类型的问题。从而实现代码的最大程度的复用。

public <K,V> Map<K,V> transfer(List<V> list, Function<V,K> function){
    Map<K,V> map = new HashMap<>();
    for (V v : list) {
        K apply = function.apply(v);
        map.put(apply, v);
    }
    return map;
} 
public Map<String,Staff> transferStaff(List<Staff> list){
    return transfer(list, Staff::getDesc);
}
public Map<String,Sword> transferSword(List<Sword> list){
    return transfer(list, Sword::getDesc);
}

确保类型安全

在没有泛型前，如果我们想要实现参数化数据类型的效果，往往需要把相对应的参数定义为Object基类。以日常我们使用的数组为例子，数据类型参数化后的结果如下所示：

在这里插入图片描述

然而，这样的设计其实是存在极大风险的，相当于一个数组内可能存在不同类型的数据。如果在取出的时候执行了强制转换，那么此时就可能出现ClassCastException。

而如果通过泛型定义，编译器就可以在添加元素的时候对加入的类型做判断。从而避免一些取值时候的不安全问题的发生。

在这里插入图片描述

消除强制转换

使用Object实现的基类数组还存在一个比较“恶心”的问题，每次取出数据的时候，都需要对取出的对象做强制转换的逻辑，十分不优雅。

    List<Object> arrays = new ArrayList<>();
    arrays.add("");
    String a = (String) arrays.get(0);

而采用了泛型后，编译器会自动转换泛型对象的数据格式，从而避免出现需要多次强制转换的情况。

    List<String> arrays = new ArrayList<>();
    arrays.add("");
    String a = arrays.get(0);

泛型的用法

使用泛型的方法主要包括两类：泛型类/接口、泛型方法

泛型类/接口

泛型类的使用方法主要通过类后设置类型参数变量，具体的语法如下所示：

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
    ......
}

泛型接口同泛型类的使用方法类似，都是在类/接口名后设置类型参数变量的方式：

public interface List<E> extends Collection<E> {
	...
    Iterator<E> iterator();
	...
}

常见的Collection的对象如：ArrayList、LinkedList等，都是采用泛型类的编写方式。而泛型接口与泛型类的不同在于，泛型接口一般都是用于定义顶层的类型用的，如List、Collection这些顶层框架的接口就会使用到这样的编写方式。

泛型方法

泛型方法的使用方式也不复杂。通过在方法返回值前设置类型参数变量即可。如下是ArraysList中的一个泛型方法：

public <T> T[] toArray(T[] a) {
    if (a.length < size)
        // Make a new array of a's runtime type, but my contents:
        return (T[]) Arrays.copyOf(elementData, size, a.getClass());
    System.arraycopy(elementData, 0, a, 0, size);
    if (a.length > size)
        a[size] = null;
    return a;
}

通配符及上下限

通配符

泛型在使用的过程中，除了通过<T>定义方法和类，在创建对象的时候还可以通过<?>表达泛型的概念，如下是一个实际的例子：

	List<?> arrays;

其中<?>被称为通配符，上述代码的含义是可以匹配任意类型的数组，同List<Object>表达的意思本质上是一致的。

上下限

在实际情况中，通配符还存在一些需要界定范围的情况。比如需要创建一个仅能存放Float、Double、Integer等数字类型的数组，那么最简单的List<?>的方法就不能够满足需求了，需要做更仔细的约束，而这就涉及到上下限了。上下限，顾名思义主要有两个：

上限：关键词是extends，其表达的意思是，数组arrays内的类都继承自Number，是Number或者Number的子类。代码如下：

	List<? extends Number> arrays = new ArrayList<>();

下限：关键词是super，其表达的意思是，对应的类都是Number或Number的父类。代码如下：

	List<? super Number> arrays = new ArrayList<>();

上下限的概念不复杂，但你可能有疑惑了，这两该咋用呢？别急，让我们来看下面这个例子：

	Integer myInteger = 1;
	List<? extends Number> arrays1 = new ArrayList<>();
	arrays1.add(myInterger); // 这个会报错
    for (Number number : arrays1) {//不会报错
		......
    }

	List<? super Number> arrays2 = new ArrayList<>();
	arrays1.add(myInterger); // 这个不会报错
	for (Number number : arrays1) {// 报错
		......
    }

上述代码想表达的意思很简单：

在添加的时候，往泛型上限表达的数组arrays1中添加Integer对象报错了，但是在往下限数组arrays2中添加元素的时候却没有报错。在遍历的时候，对arrays1按Number做遍历没有报错，但是对arrays2按Number遍历元素却报错了。这是为什么呢？我们逐一来分析：

添加数据：

在添加数据时，List<Integer>、List<Long>这些类型都可以理解为List<?>或者List<? extends Number>的子类型。这时候如果往List中add数据，编译器没法判断添加的是Integer、Integer还是Double类型。可能会引发类型不一致的问题，这显然和泛型的设计是相悖的。因此Java为了保证类型一致，不允许往泛型上限的数据内添加元素。

然而，对于List<? super Number>来说，其可以理解为List<Number>的父类型，显然List<Number>是可以添加Numer的子类型数据的。

遍历数据：

而在遍历数据的时候，情况就相反了。List<? extends Number>确保了其子类都是继承自Number的。因此可以采用Number对象进行遍历。

但是对于List<? super Number>的数组来说，情况就相反了。因为编译器没法确定所遍历到的对象究竟是Number还是Number的父类，因此只能采用Object对象进行遍历，而并不支持按照Number对象进行遍历的方式。

适用范围

结合上述的讨论，其实还可以得出一个比较重要的点：**通配符下限支持添加、通配符上限支持遍历。**由此在方法的设计上，可以优先考虑以通配符上线作为入参，以通配符的下限作为方法的出参。下面是一个具体的示例：

public static List<? super Number> transfer(List<? extends Number> numbers){
    List<? super Number> outputs = new ArrayList<>();
    for (Number number : numbers) {
        outputs.add(number);
    }
    return outputs;
}

泛型原理

介绍了这么多泛型的定义和用法，那么泛型本身又是如何实现的呢？

相比较C++的泛型实现方式（模版 + 重载），其实JAVA的实现方式很简单，编译器会在编译的时候将使用泛型的类型给擦除掉，都当作默认的Object对象进行处理。这种实现方式也被称为类型擦除。且实际上，编译器并没有根据类型编译出新的代码，JAVA所实现的泛型，也被称为假泛型。

泛型翻译

知道了泛型的实现原理以后，我们还需要关注一种情况。这里首先引入泛型类Pair：

public class Pair<T> {
    private T first;

    public void setFirst(T first) {
        this.first = first;
    }
}

紧接着我们继承该泛型类，并实现一个IntPair对象。IntPair对象中，对原有的set方法做了一次重写。

public class IntPair extends Pair<Integer>{

    @Override
    public void setFirst(Integer first) {
        super.setFirst(first);
    }
}

但是借由上面对泛型原理的分析，我们不难理解Pair对象的set的方法其实会被翻译成Obejct对象，即如下所示：

public class Pair<Object> {
    private Object first;

    public void setFirst(Object first) {
        this.first = first;
    }
}

但是我们子类的方法确实实打实的Integer对象呀，这还如何实现重写呢？为了探究这块的实现奥秘，我们有必要对IntPair对象做一次反编译：

public class com.example.demo.service.genericparadigm.IntPair extends com.example.demo.service.genericparadigm.Pair<java.lang.Integer> {
  public com.example.demo.service.genericparadigm.IntPair();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method com/example/demo/service/genericparadigm/Pair."<init>":()V
       4: return

  public void setFirst(java.lang.Integer);
    Code:
       0: aload_0
       1: aload_1
       2: invokespecial #2                  // Method com/example/demo/service/genericparadigm/Pair.setFirst:(Ljava/lang/Object;)V
       5: return

  public void setFirst(java.lang.Object);
    Code:
       0: aload_0
       1: aload_1
       2: checkcast     #3                  // class java/lang/Integer
       5: invokevirtual #4                  // Method setFirst:(Ljava/lang/Integer;)V
       8: return
}

可以看到，编译器实际上生成了两个方法，一个是预期重写的setFirst(Integer i)方法，而另外一个则是父类的setFirst(Object i)方法。通过上述编译的代码不难看出，java实际上是在setFirst(Integer i)中调用了setFirst(object i)方式实现了代码的重写。这种方式，也被称为桥接方式。通过采用桥接方式，子类就可以成功的对父类中的泛型方法做重载了。