五、Kotlin泛型

泛型

泛型（Generic Type）简介

通常情况的类和函数，我们只需要使用具体的类型即可：要么是基本类型，要么是自定义的类。

但是尤其在集合类的场景下，我们需要编写可以应用于多种类型的代码，我们最简单原始的做法是，针对每一种类型，写一套刻板的代码。

这样做，代码复用率会很低，抽象也没有做好。

在SE 5种，Java引用了泛型。泛型，即“参数化类型”（Parameterized Type）。顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式，我们称之为类型参数，然后在使用时传入具体的类型（类型实参）。

我们知道，在数学中泛函是以函数为自变量的函数。类比的来理解，编程中的泛型就是以类型为变量的类型，即参数化类型。这样的变量参数就叫类型参数(Type Parameters)。

本章我们来一起学习一下Kotlin泛型的相关知识。

1 为什么要有类型参数

我们先来看下没有泛型之前，我们的集合类是怎样持有对象的。

在Java中，Object类是所有类的根类。为了集合类的通用性。我们把元素的类型定义为Object，当放入具体的类型的时候，再作强制类型转换。

这是一个示例代码：

class RawArrayList {
public int length = 0;
private Object[] elements;

public RawArrayList(int length) {
    this.length = length;
    this.elements = new Object[length];
}

public Object get(int index) {
    return elements[index];
}

public void add(int index, Object element) {
    elements[index] = element;
}

@Override
public String toString() {
    return "RawArrayList{" +
        "length=" + length +
        ", elements=" + Arrays.toString(elements) +
        '}';
  }
}

一个简单的测试代码如下：

public class RawTypeDemo {

public static void main(String[] args) {
    RawArrayList rawArrayList = new RawArrayList(4);
    rawArrayList.add(0, "a");
    rawArrayList.add(1, "b");
    System.out.println(rawArrayList);

    String a = (String)rawArrayList.get(0);
    System.out.println(a);

    String b = (String)rawArrayList.get(1);
    System.out.println(b);

    rawArrayList.add(2, 200);
    rawArrayList.add(3, 300);
    System.out.println(rawArrayList);

    int c = (int)rawArrayList.get(2);
    int d = (int)rawArrayList.get(3);
    System.out.println(c);
    System.out.println(d);

    //Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
    String x = (String)rawArrayList.get(2);
    System.out.println(x);

     }

}

我们可以看出，在使用原生态类型（raw type）实现的集合类中，我们使用的是Object[]数组。这种实现方式，存在的问题有两个：

• 向集合中添加对象元素的时候，没有对元素的类型进行检查，也就是说，我们往集合中添加任意对象，编译器都不会报错。

• 当我们从集合中获取一个值的时候，我们不能都使用Object类型，需要进行强制类型转换。而这个转换过程由于在添加元素的时候没有作任何的类型的限制跟检查，所以容易出错。例如上面代码中的：

     String a = (St`ring)rawArrayList.get(0);
  

对于这行代码，编译时不会报错，但是运行时会抛出类型转换错误。

由于我们不能笼统地把集合类中所有的对象是视作Object，然后在使用的时候各自作强制类型转换。因此，我们引入了类型参数来解决这个类型安全使用的问题。

Java 中的泛型是在1.5 之后加入的，我们可以为类和方法分别定义泛型参数，比如说Java中的Map接口的定义：

public interface Map {
...
boolean containsKey(Object key);
boolean containsValue(Object value);
V get(Object key);
V put(K key, V value);
V remove(Object key);
void putAll(Map m);
Set keySet();
Collection values();
Set> entrySet();
default V getOrDefault(Object key, V defaultValue) {
V v;
return (((v = get(key)) != null) || containsKey(key))
? v
: defaultValue;
}
}

我们在Kotlin 中的写法基本一样：

public interface Map {
...
public fun containsKey(key: K): Boolean
public fun containsValue(value: @UnsafeVariance V): Boolean
public operator fun get(key: K): V?
@SinceKotlin("1.1")
@PlatformDependent
public fun getOrDefault(key: K, defaultValue: @UnsafeVariance V): V {
// See default implementation in JDK sources
return null as V
}
public val keys: Set
public val values: Collection
public val entries: Set>

}

public interface MutableMap : Map {
public fun put(key: K, value: V): V?
public fun remove(key: K): V?
public fun putAll(from: Map): Unit
...

}

比如，在实例化一个Map时，我们使用这个函数：

fun  mapOf(vararg pairs: Pair): Map

类型参数K，V是一个占位符，当泛型类型被实例化和使用时，它将被一个实际的类型参数所替代。

代码示例

>>> val map = mutableMapOf(1 to "a", 2 to "b", 3 to "c")
>>> map
{1=a, 2=b, 3=c}
>>> map.put(4,"c")
null
>>> map
{1=a, 2=b, 3=c, 4=c}

mutableMapOf表示参数化类型分别是Int 和 String，这是泛型类型集合的实例化，在这里，放置K， V 的位置被具体的Int 和 String 类型所替代。

泛型主要是用来限制集合类持有的对象类型，这样使得类型更加安全。当我们在一个集合类里面放入了错误类型的对象，编译器就会报错：

>>> map.put("5","e")
error: type mismatch: inferred type is String but Int was expected
map.put("5","e")
^

Kotlin中有类型推断的功能，有些类型参数可以直接省略不写。上面的mapOf后面的类型参数可以省掉不写：

>>> val map = mutableMapOf(1 to "a", 2 to "b", 3 to "c")
>>> map
{1=a, 2=b, 3=c}

Java和Kotlin 的泛型实现，都是采用了运行时类型擦除的方式。也就是说，在运行时，这些类型参数的信息将会被擦除。Java 和Kotlin 的泛型对于语法的约束是在编译期。

2 型变（Variance）

2.1 Java的类型通配符

Java 泛型的通配符有两种形式。我们使用

• 子类型上界限定符? extends T 指定类型参数的上限（该类型必须是类型T或者它的子类型）
• 超类型下界限定符? super T 指定类型参数的下限（该类型必须是类型T或者它的父类型）

我们称之为类型通配符(Type Wildcard)。默认的上界（如果没有声明）是 Any?，下界是Nothing。

代码示例：

class Animal {

public void act(List list) {
    for (Animal animal : list) {
        animal.eat();
    }
}

public void aboutShepherdDog(List list) {
    System.out.println("About ShepherdDog");
}

public void eat() {
    System.out.println("Eating");
}

}

class Dog extends Animal {}

class Cat extends Animal {}

class ShepherdDog extends Dog {}

我们在方法act(List list)中, 这个list可以传入以下类型的参数：

List
List
List
List

测试代码：

    List list3 = new ArrayList<>();
    list3.add(new Dog());
    list3.add(new Cat());
    animal.act(list3);

    List list4 = new ArrayList<>();
    list4.add(new Dog());
    list4.add(new Dog());
    animal.act(list4);

    List list5 = new ArrayList<>();
    list5.add(new Cat());
    list5.add(new Cat());
    animal.act(list5);

为了更加简单明了说明这些类型的层次关系，我们图示如下：

对象层次类图：

集合类泛型层次类图：

也就是说，List并不是List的子类型，而是两种不存在父子关系的类型。

而List是List，List等的父类型，对于任何的List这里的X只要是Animal的子类型，那么List就是List的父类型。

使用通配符List的引用, 我们不可以往这个List中添加Animal类型以及其子类型的元素：

    List list1 = new ArrayList<>();

    list1.add(new Dog());
    list1.add(new Animal());

这样的写法，Java编译器是不允许的。

螢幕快照 2017-06-30 23.46.12.png

因为对于set方法，编译器无法知道具体的类型，所以会拒绝这个调用。但是，如果是get方法形式的调用，则是允许的：

List list1 = new ArrayList<>();
List list4 = new ArrayList<>();
list4.add(new Dog());
list4.add(new Dog());
animal.act(list4);
list1 = list4;
animal.act(list1);

我们这里把引用变量List list1直接赋值List list4, 因为编译器知道可以把返回对象转换为一个Animal类型。

相应的，? super T超类型限定符的变量类型List的层次结构如下：

螢幕快照 2017-06-30 23.56.35.png

在Java中，还有一个无界通配符，即单独一个?。如List，?可以代表任意类型，“任意”是未知类型。例如:

Pair

参数替换后的Pair类有如下方法:

? getFirst()
void setFirst(?)

我们可以调用getFirst方法，因为编译器可以把返回值转换为Object。
但是不能调用setFirst方法，因为编译器无法确定参数类型。

通配符在类型系统中具有重要的意义，它们为一个泛型类所指定的类型集合提供了一个有用的类型范围。泛型参数表明的是在类、接口、方法的创建中，要使用一个数据类型参数来代表将来可能会用到的一种具体的数据类型。它可以是Integer类型，也可以是String类型。我们通常把它的类型定义成 E、T 、K 、V等等。

当我们在实例化对象的时候，必须声明T具体是一个什么类型。所以当我们把T定义成一个确定的泛型数据类型，参数就只能是这种数据类型。此时，我们就用到了通配符代替指定的泛型数据类型。

如果把一个对象分为声明、使用两部分的话。泛型主要是侧重于类型的声明的代码复用，通配符则侧重于使用上的代码复用。泛型用于定义内部数据类型的参数化，通配符则用于定义使用的对象类型的参数化。

使用泛型、通配符提高了代码的复用性。同时对象的类型得到了类型安全的检查，减少了类型转换过程中的错误。

2.2 协变（covariant）与逆变（contravariant）

在Java中数组是协变的，下面的代码是可以正确编译运行的：

    Integer[] ints = new Integer[3];
    ints[0] = 0;
    ints[1] = 1;
    ints[2] = 2;
    Number[] numbers = new Number[3];
    numbers = ints;
    for (Number n : numbers) {
        System.out.println(n);
    }

在Java中，因为 Integer 是 Number 的子类型，数组类型 Integer[] 也是 Number[] 的子类型，因此在任何需要 Number[] 值的地方都可以提供一个 Integer[] 值。

而另一方面，泛型不是协变的。也就是说， List 不是 List 的子类型，试图在要求 List 的位置提供 List 是一个类型错误。下面的代码，编译器是会直接报错的：

    List integerList = new ArrayList<>();
    integerList.add(0);
    integerList.add(1);
    integerList.add(2);
    List numberList = new ArrayList<>();
    numberList = integerList;

编译器报错提示如下：

螢幕快照 2017-07-01 00.59.16.png

Java中泛型和数组的不同行为，的确引起了许多混乱。

就算我们使用通配符，这样写：

List list = new ArrayList();  
list.add(new Integer(1)); //error  

仍然是报错的：

螢幕快照 2017-07-01 01.03.54.png

为什么Number的对象可以由Integer实例化，而ArrayList的对象却不能由ArrayList实例化？list中的声明其元素是Number或Number的派生类，为什么不能add Integer?为了解决这些问题，需要了解Java中的逆变和协变以及泛型中通配符用法。

逆变与协变

Animal类型（简记为F, Father）是Dog类型（简记为C, Child）的父类型，我们把这种父子类型关系简记为F <| C。

而List, List的类型，我们分别简记为f(F), f(C)。

那么我们可以这么来描述协变和逆变：

当F <| C 时, 如果有f(F) <| f(C),那么f叫做协变（Convariant）；
当F <| C 时, 如果有f(C) <| f(F),那么f叫做逆变（Contravariance）。
如果上面两种关系都不成立则叫做不可变。

协变和逆协变都是类型安全的。

Java中泛型是不变的，可有时需要实现逆变与协变，怎么办呢？这时就需要使用我们上面讲的通配符? 。

实现了泛型的协变

List list = new ArrayList<>();  

这里的? extends Number表示的是Number类或其子类，我们简记为C。

这里C <| Number，这个关系成立：List <| List< Number >。即有：

List list1 = new ArrayList();  
List list2 = new ArrayList();  

但是这里不能向list1、list2添加除null以外的任意对象。

    list1.add(null);
    list2.add(null);

    list1.add(new Integer(1)); // error

因为，List可以添加Interger及其子类，List可以添加Float及其子类，List、List都是List的子类型，如果能将Float的子类添加到List中，那么也能将Integer的子类添加到List中, 那么这时候List里面将会持有各种Number子类型的对象（Byte，Integer，Float，Double等等）。Java为了保护其类型一致，禁止向List添加任意对象，不过可以添加null。

螢幕快照 2017-07-01 01.25.30.png

实现了泛型的逆变

List list = new ArrayList<>();  

? super Number 通配符则表示的类型下界为Number。即这里的父类型F是? super Number, 子类型C是Number。即当F <| C , 有f(C) <| f(F) ， 这就是逆变。代码示例：

    List list3 = new ArrayList();  
    List list4 = new ArrayList