6.1 泛型（Generic Type）简介

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

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

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

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

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

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

6.1.1 为什么要有类型参数

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

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

这是一个示例代码：

  1. class RawArrayList {
  2.     public int length = 0;
  3.     private Object[] elements;
  5.     public RawArrayList(int length) {
  6.         this.length = length;
  7.         this.elements = new Object[length];
  8.     }
  10.     public Object get(int index) {
  11.         return elements[index];
  12.     }
  14.     public void add(int index, Object element) {
  15.         elements[index] = element;
  16.     }
  18.     @Override
  19.     public String toString() {
  20.         return "RawArrayList{" +
  21.             "length=" + length +
  22.             ", elements=" + Arrays.toString(elements) +
  23.             '}';
  24.     }
  25. }

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

  1. public class RawTypeDemo {
  3.     public static void main(String[] args) {
  4.         RawArrayList rawArrayList = new RawArrayList(4);
  5.         rawArrayList.add(0, "a");
  6.         rawArrayList.add(1, "b");
  7.         System.out.println(rawArrayList);
  9.         String a = (String)rawArrayList.get(0);
  10.         System.out.println(a);
  12.         String b = (String)rawArrayList.get(1);
  13.         System.out.println(b);
  15.         rawArrayList.add(2, 200);
  16.         rawArrayList.add(3, 300);
  17.         System.out.println(rawArrayList);
  19.         int c = (int)rawArrayList.get(2);
  20.         int d = (int)rawArrayList.get(3);
  21.         System.out.println(c);
  22.         System.out.println(d);
  24.         // Exception in thread "main" java.lang.ClassCastException: 
  25.           // java.lang.Integer cannot be cast to java.lang.String
  26.         String x = (String)rawArrayList.get(2);
  27.         System.out.println(x);
  28.     }
  29. }

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

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

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

  1. String a = (String)rawArrayList.get(0);

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

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

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

  1. public interface Map<K,V> {
  2.     ...
  3.     boolean containsKey(Object key);
  4.     boolean containsValue(Object value);
  5.     V get(Object key);
  6.     V put(K key, V value);
  7.     V remove(Object key);
  8.     void putAll(Map<? extends K, ? extends V> m);
  9.     Set<K> keySet();
  10.     Collection<V> values();
  11.     Set<Map.Entry<K, V>> entrySet();
  12.     default V getOrDefault(Object key, V defaultValue) {
  13.         V v;
  14.         return (((v = get(key)) != null) || containsKey(key))
  15.             ? v
  16.             : defaultValue;
  17.     }
  18. }

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

  1. public interface Map<K, out V> {
  2.     ...
  3.     public fun containsKey(key: K): Boolean
  4.     public fun containsValue(value: @UnsafeVariance V): Boolean
  5.     public operator fun get(key: K): V?
  6.     @SinceKotlin("1.1")
  7.     @PlatformDependent
  8.     public fun getOrDefault(key: K, defaultValue: @UnsafeVariance V): V {
  9.         // See default implementation in JDK sources
  10.         return null as V
  11.     }
  12.     public val keys: Set<K>
  13.     public val values: Collection<V>
  14.     public val entries: Set<Map.Entry<K, V>>
  16. }
  18. public interface MutableMap<K, V> : Map<K, V> {
  19.     public fun put(key: K, value: V): V?
  20.     public fun remove(key: K): V?
  21.     public fun putAll(from: Map<out K, V>): Unit
  22.     ...
  23. }

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

  1. fun <K, V> mapOf(vararg pairs: Pair<K, V>): Map<K, V>

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

代码示例

  1. >>> val map = mutableMapOf<Int,String>(1 to "a", 2 to "b", 3 to "c")
  2. >>> map
  3. {1=a, 2=b, 3=c}
  4. >>> map.put(4,"c")
  5. null
  6. >>> map
  7. {1=a, 2=b, 3=c, 4=c}

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

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

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

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

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

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