深入理解Java\Kotlin泛型

泛型产生

Java泛型是JDK1.5引入的一个新特性，是一种参数化类型。参数化类型就是在不创建新类型的情况下，通过泛型指定的泛泛类型控制形参限制的类型。允许在编译期检测非法类型。

泛型特点

• 类型安全。使用泛型定义的参数进行，在编译期可以对一个类型进行验证，从而更快的暴露问题
• 消除强制类型转换。
• 避免了不必要的装箱、拆箱操作，提高程序性能
• 提高代码的重用性

命名类型参数

• E - 元素，主要由Java集合(Collections)框架使用。
• K - 键，主要用于表示映射中的键的参数类型。
• V - 值，主要用于表示映射中的值的参数类型。
• N - 数字，主要用于表示数字。
• T - 类型，主要用于表示第一类通用型参数。
• S - 类型，主要用于表示第二类通用类型参数。
• U - 类型，主要用于表示第三类通用类型参数。
• V - 类型，主要用于表示第四个通用类型参数。

泛型定义

泛型类

泛型类的声明和普通类声明类似，除了在类名后添加类型参数声明。
定义

修饰符 class 类名<声明自定义泛型> {
    ...
}

实例

public static void main(String[] args) {
    Container c1 = new Container<>("name", "kevin");
    Container c2 = new Container<>("age", 29);
    Container c3 = new Container<>(1.0, 29);
}
public static class Container {
    K key;
    V value;
    Container(K k, V v) {
        key = k;
        value = v;
    }
}

泛型接口

定义

修饰符 interface 接口名<声明自定义泛型>{

}

实例

public interface Generator {
    T init();
}

public class GeneratorClass1 implements Generator {
    @Override
    public String init() {
        return "test1";
    }
}

public class GeneratorClass2 implements Generator {
    @Override
    public Integer init() {
        return 0;
    }
}

泛型方法

定义

修饰符 返回值类型 接口名<声明自定义泛型>{

}

实例

public interface Generator {
    T init();
}

public class GeneratorClass1 implements Generator {
    @Override
    public String init() {
        return "test1";
    }
}

public class GeneratorClass2 implements Generator {
    @Override
    public Integer init() {
        return 0;
    }
}

通配符

通配符的产生

任何使用父类的地方可以被它的子类替换，我们在使用类和对象时经常会接触到里式替换原则，其实在数组中一样也符合这种原则
如下：

  class Fruit {}
    class Apple extends Fruit {}
    class Jonathan extends Apple {}
    class Orange extends Fruit {}

    public class CovariantArrays {
        public  void main(String[] args) {
            Fruit[] fruit = new Apple[10]; // OK
            List fruits=new ArrayList();//error
            fruit[0] = new Apple(); // OK
            fruit[1] = new Jonathan(); // OK
            // Runtime type is Apple[], not Fruit[] or Orange[]:
            try {
                // Compiler allows you to add Fruit:
                fruit[0] = new Fruit(); // ArrayStoreException
            } catch(Exception e) { System.out.println(e); }
            try {
                // Compiler allows you to add Oranges:
                fruit[0] = new Orange(); // ArrayStoreException
            } catch(Exception e) { System.out.println(e); }
        }
    }

数组中的这种向上转变称为数组协变，而泛型是不支持的，如下代码

 List fruits=new ArrayList();//error

如上代码会产生编译时错误，之所以这么设计是因为数组支持运行时检查而集合不支持运行时检查。

Java的泛型的这种特性对于有需要向上转型的需求时就无能为力，所以 Java 为了满足这种需求设计出了通配符.

上边界限定通配符[Java]/协变[Kotln]

Java

Java语言利用 形式的通配符可以实现泛型的向上转型：

 static void ccc() {
    Apple apple = new Apple();
    apple.name = "Apple";
    ArrayList fruits = new ArrayList<>();
    fruits.add(apple); //Error

    for (int i = 0; i < fruits.size(); i++) {
        Fruit fruit = (Fruit) fruits.get(i);
        System.out.println("println---" + fruit.name);
    }
}

Kotlin

Kotlin语言利用形式的通配符实现泛型的向上转型：

 fun ccc() {
    val apple = Apple()
    apple.name = "Apple"
    val fruits: ArrayList = ArrayList()
    fruits.add(apple) //Error
    for (i in fruits.indices) {
        println("println---" + fruits[i].name)
    }
}

使用上通配符后编译器为了保证运行时的安全，会限定对其写的操作，开放读的操作，因为编译器只能保证 fruits 集合中存在的是 Fruits 及它的子类，并不知道具体的类型，所以上述代码fruits.add(apple)会报错

下边界限定通配符[Java]/逆变[Kotln]

Java

Java语言利用 形式的通配符可以实现泛型的向上转型：

static void ccc() {
    Apple apple = new Apple();
    apple.name = "Apple";
    ArrayList fruits = new ArrayList<>();
    fruits.add(apple);//OK
    fruits.add(new Fruits()); //Error
    for (int i = 0; i < fruits.size(); i++) {
        Apple fruit = fruits.get(i);//Error
        System.out.println("println---" + fruit.name);
    }
}

Kotlin

Kotlin语言利用形式的通配符实现泛型的向上转型：

fun ccc() {
    val apple = Apple()
    apple.name = "Apple"
    val fruits: ArrayList = ArrayList()
    fruits.add(apple) //OK
    fruits.add(new Fruits()) //Error
    for (i in fruits.indices) {
        println("println---" + fruits[i].name) //error
    }
}

与上边界通配符相反，下边界通配符通常限定读的操作，开放写的操作，对于如上代码，它标示某种类型的List，这个类型是Apple的基础类型。也就是说，我们实际上并不知道类型是什么，但是这个类型肯定是Apple的父类型。因此，我们知道向这个List添加一个Apple对象或者其子类型对象是安全的，这些对象都可以向上转型为Apple。但是我们不知道加入Fruit对象是否安全，

无边界通配符[Java]/星投影[Kotln]

还有一种通配符是无边界通配符，它的使用形式是一个单独的问号：List，也就是没有任何限定

Java

kotlin

<*>

无边界通配符或星投影是没有任何限定的，正是由于其没任何限定，所以我们并不能确定参数是哪种类型，此时我们也是不可以往其中添加对象的。

MutableList和MutableList有什么区别呢？

如下代码

Java

  List list1 = new ArrayList<>();
  aaa.add(""); //Error

  List list2 = new ArrayList();
  aaa1.add(""); //Ok

Kotlin

  val list1: MutableList<*> = mutableListOf()
  fruits.add(Fruit()) //Error

  val list2: MutableList = mutableListOf()
  fruits.add(Fruit()) //OK

MutableList<*> list 表示 list 是持有某种特定类型的 MutableList，但是不知道具体是哪种类型。那么我们可以向其中添加对象吗？当然不可以，因为并不知道实际是哪种类型，所以不能添加任何类型，这是不安全的。而 MutableList list ，也就是没有传入泛型参数，表示这个 list 持有的元素的类型是 Any也就是Object，因此可以添加任何类型的对象，只不过编译器会有警告信息。

泛型参数约束

单个泛型参数约束[Java]/[Kotln]

单个泛型约束还是很简单的，Java中我们使用extends进行约束，Kotlin中使用：

我们想实现两个泛型参数的比较，使用Comparable进行比较，代码如下：

Java

public > T maxOf(T params1, T params2) {
    if (params1.compareTo(params2) > 0) {
        return params1;
    } else {
        return params2;
    }
}

Kotlin

fun > maxOf(params1: T, params2: T): T {
    return if (params1 > params2) {
        params1
    } else{
        params2
    }
}

单个约束我们在之前已经了解情况了，那如果我们想实现多个约束该怎么办呢？

多个泛型参数约束[Java]/[Kotlin]

Java中实现多个泛型参数使用& Supplier，而Kotlin中使用where

还是如上代码，我们改造一下：

Java

 & Supplier, R extends String> R maxOf(T params1, T params2) {
    if (params1.compareTo(params2) > 0) {
        return params1.get();
    } else {
        return params2.get();
    }
}

Kotlin

fun  maxOf(params1: T, params2: T): R where T: Comparable, T:() ->R {
    if (params1 > params2) {
        return params1.invoke()
    } else {
        return params2.invoke()
    }
}

类型擦除

我们都知道，Java的泛型是伪泛型，这是因为Java在编译期间，所有的泛型信息都会被擦掉，正确理解泛型概念的首要前提是理解类型擦除。Java的泛型基本上都是在编译器这个层次上实现的，在生成的字节码中是不包含泛型中的类型信息的，使用泛型的时候加上类型参数，在编译器编译的时候会去掉，这个过程成为类型擦除。

例如定义List