注册

扫盲:Kotlin 的泛型(1)

扫盲:Kotlin 的泛型">

引子

南尘很久没有写文章啦,其实一直在思考挺多问题,如何才能写出对大家有价值的文字。思来想去,参看了好几位新继网红博主的风格,我觉得我时候开启新篇章了。没错,这就是扫盲。

今天,就带来扫盲的第一篇:Kotlin 的泛型。

相信总是有很多同学,总是在抱怨泛型无论怎么学习,都只是停留在一个简单使用的水平,所以一直为此而备受苦恼。

Kotlin 作为一门能和 Java 相互调用的语言,自然也支持泛型,不过 Kotlin 的新关键字 in  out 却总能绕晕一部分人,归根结底,还是因为 Java 的泛型基本功没有足够扎实。

很多同学总是会产生这些疑问:

  • Kotlin 泛型和 Java 泛型到底有何区别?
  • Java 泛型存在的意义到底是什么?
  • Java 的类型擦除到底是指什么?
  • Java 泛型的上界、下界、通配符到底有何区别?它们可以实现多重限制么?
  • Java 的 <? extends T><? super T><?> 到底对应了什么?有哪些使用场景?
  • Kotlin 的 inout*where 到底有何魔力?
  • 泛型方法又是什么?

今天,就用一篇文章为大家解除上述疑惑。

泛型:类型安全的利刃

总所周知,Java 在 1.5 之前,是没有泛型这个概念的。那时候的 List 还只是一个可以装下一切的集合。所以我们难免会写上这样的代码:

List list = new ArrayList();
list.add(1);
list.add("nanchen2251");
String str = (String) list.get(0);
复制代码

上面的代码编译并没有任何问题,但运行的时候一定会出现常见的 ClassCastException 异常:

Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
复制代码

这个体验非常糟糕,我们真正需要的是在代码编译的时候就能发现错误,而不是让错误的代码发布到生产环境中。

而如果上述代码我们增加上泛型,就会在编译期就能看到明显的错误啦。

List<String> list = new ArrayList<>();
list.add(1);
// 👆 报错 Required type:String but Provided:int
list.add("nanchen2251");
String str = list.get(0);
复制代码

很明显,泛型的出现,让类型更加安全,使我们在使用 ListMap 等不再需要去专门编写 StringListStringMap 了,只需要在声明 List 的同时指定参数类型即可。

总的来说,泛型具备以下优势:

  • 类型检查,能在编译时就帮开发检查出错误;
  • 更加语义化,比如我们声明一个 LIst<String>,我们可以很直接知道里面存储的是 String 对象;
  • 能自动进行类型转换,获取数据的时候不需要再做强转操作;
  • 能写出更加通用化的代码。

类型擦除

可能有些同学思考过这样一个问题,既然泛型是和类型相关的,那么是不是也能使用类型的多态呢?

我们知道,一个子类型是可以赋值给父类型的,比如:

Object obj = "nanchen2251";
// 👆 这是多态
复制代码

Object 作为 String 的父类,自然可以接受 String 对象的赋值,这样的代码我们早已司空见惯,并没有什么问题。

但当我们写下这串代码:

List<String> list = new ArrayList<String>();
List<Object> objects = list;
// 👆 多态用在这里会报错 Required type:List<Object> Provided: List<String>
复制代码

上面发生了赋值错误,这是因为 Java 的泛型本身具有「不可变性 Invariance」,Java 里面认为 List<String>  List<Object> 类型并不一致,也就是说,子类的泛型 List<String> 不属于泛型 List<Object> 的子类。

由于 Java 的泛型本身是一种 「伪泛型」,Java 为了兼容 1.5 以前的版本,不得以在泛型底层实现上使用 Object 引用,所以我们声明的泛型在编译时会发生「类型擦除」,泛型类型会被 Object 类型取代。比如:

class Demo<T> {
void func(T t){
// ...
}
}
复制代码

会被编译成:

class Demo {
void func(Object t){
// ...
}
}
复制代码

可能你会好奇,在编译时发生类型擦除后,我们的泛型都被更换成了 Object,那为什么我们在使用的时候,却不需要强转操作呢?比如:

List<String> list = new ArrayList<>();
list.add("nanchen2251");
String str = list.get(0);
// 👆 这里并没有要求我们把 list.get(0) 强转为 String
复制代码

这是因为编译器会根据我们声明的泛型类型进行提前的类型检查,然后再进行类型擦除,擦除为 Object,但在字节码中其实还存储了我们的泛型的类型信息,在使用到泛型类型的时候会把擦除后的 Object 自动做类型强转操作。所以上面的 list.get(0) 本身就是一个经过强转的 String 对象了。

这个技术看起来还蛮好的,但却有一个弊端。就是既然擦成 Object 了,那么在运行的时候,你根本不能确定这个对象到底是什么类型,虽然你可以通过编译器帮你插入的 checkcast 来获得此对象的类型。但是你并不能把 T 真正的当作一个类型使用:比如这条语句在 Java 中是非法的。

T a = new T();
// 👆 报错:Type parameter 'T' cannot be instantiated directly
复制代码

同理,因为都被擦成了 Object,你就不能根据类型来做某种区分。

比如 instanceof

if("nanchen2251" instanceof T.class){
// 👆 报错:Identifier expected Unexpected token
}
复制代码

比如重载:

void func(T t){
// 👆 报错:'func(T)' clashes with 'func(E)'; both methods have same erasure
}
void func(E e){
}
复制代码

同样,因为基本数据类型不属于 oop,所以也不能被擦除为 Object,所以 Java 的泛型也不能用于基本类型:

List<int> list;
// 👆 报错:Type argument cannot be of primitive type
复制代码

oop:面向对象的程序设计(Object Oriented Programming)

到这里,是不是可以回答上面的第 3 个问题了:Java 的类型擦除到底是指什么?

首先你要明白一点,一个对象的类型永远不会被擦出的,比如你用一个 Object 去引用一个 Apple 对象,你还是可以获得到它的类型的。比如用 RTTI。

RTTI:运行时类型信息,运行时类型识别 (Run Time Type Identification)

Object object = new Apple();
System.out.println(object.getClass().getName());
// 👆 will print Apple
复制代码

哪怕它是放到泛型里的。

class FruitShop<T>{
private T t;

public void set(T t){
this.t = t;
}

public void showFruitName(){
System.out.println(t.getClass().getName());
}
}
FruitShop<Apple> appleShop = new FruitShop<Apple>();
appleShop.set(new Apple());
appleShop.showFruitName();
// 👆 will print Apple too
复制代码

为啥?因为引用就是一个用来访问对象的标签而已,对象一直在堆上放着呢。

所以不要断章取义认为类型擦除就是把容器内对象的类型擦掉了,所谓的类型擦除,是指容器类FruitShop<Apple>,对于 Apple 的类型声明在编译期的类型检查之后被擦掉,变为和 FruitShop<Object> 等同效果,也可以说是 FruitShop<Apple>  FruitShop<Banana> 被擦为和 FruitShop<Object> 等价,而不是指里面的对象本身的类型被擦掉!

那,Kotlin 中有类型擦除么?

C# 和 Java 在一开始都是不支持泛型的。Java 在 1.5 开始才加入了泛型。为了让一个不支持泛型的语言支持泛型,只有两条路可以走:

  • 以前的非泛型容器保持不变,然后平行的增加一套泛型化的类型。
  • 直接把已有的非泛型容器扩展为泛型,不添加任何新的泛型版本。

Java 由于 1.5 之前市面上一句有大量的代码,所以不得以选择了第 2 种方式,而 C# 比较机智就选择了第一种。

而 Kotlin 本身就是基于 Java 1.6 编写的,一开始就有泛型,不存在兼容老版本代码的问题,那 Kotlin 实现的泛型还具备类型擦除么?

当然具备。上面其实已经说的很清楚了,Kotlin 本身就是基于 Java 1.6 编写的,而且 Kotlin 和 Java 有极强的互调能力,当然也存在类型擦除。

不过...

你还是会发现有意思的点:

val list = ArrayList()
// 👆 报错:Not enough information to infer type variable E
复制代码

在 Java 中,不指定泛型类型是没问题的,但 Kotlin 这样不好使了。想来也简单,毕竟在 Java 1.5 之前是肯定不存在上述类似代码的,而泛型的设计初衷就不是用来装默认的 Kotlin Any 的。

泛型的上界通配符

前面说到:因为 Java 的泛型本身具有「不可变性 Invariance」,所以即使 Fruit 类是 Apple 类的父类,但 Java 里面认为 List<Fruit>  List<Apple> 类型并不一致,也就是说,子类的泛型 List<Apple> 不属于泛型 List<Fruit> 的子类。

所以这样的代码并不被运行。

List<Apple> apples = new ArrayList<Apple>();
List<Fruit> fruits = apples;
// 👆 多态用在这里会报错 Required type:List<Fruit> Provided: List<Apple>
复制代码

那假如我们想突破这层限制,怎么办?使用上界通配符 ? extends

List<Apple> apples = new ArrayList<Apple>();
List<? extends Fruit> fruits = apples;
// 👆使用上界通配符后,编译不再报错
复制代码

「上界通配符」,可以使 Java 泛型具有「协变性 Covariance」,协变就是允许上面的赋值是合法的。

在继承关系树中,子类继承自父类,可以认为父类在上,子类在下。extends 限制了泛型类型的父类型,所以叫上界。

它有两层意思:

  • 其中 ? 是个通配符,表示这个 List 的泛型类型是一个未知类型。
  • extends 限制了这个未知类型的上界,也就是泛型类型必须满足这个 extends 的限制条件,这里和定义 class  extends 关键字有点不一样:
    • 它的范围不仅是所有直接和间接子类,还包括上界定义的父类本身,也就是 Fruit
    • 它还有 implements 的意思,即这里的上界也可以是 interface

这个突破限制有意义么?

有的有的。

假如我们有一个接口 Fruit

interface Fruit {
float getWeight();
}
复制代码

有两个水果类实现了 Fruit 接口:

class Banana implements Fruit {
@Override
public float getWeight() {
return 0.5f;
}
}

class Apple implements Fruit {
@Override
public float getWeight() {
return 1f;
}
}
复制代码

假设我们有个需求是需要给水果称重:

List<Apple> apples = new ArrayList<>();
apples.add(new Apple());
float totalWeight = getTotalWeight(apples);
// 👆 报错:Required type: List<Fruit> Provided: List<Apple>

private float getTotalWeight(List<Fruit> fruitList) {
float totalWeight = 0;
for (Fruit fruit : fruitList) {
totalWeight += fruit.getWeight();
}
return totalWeight;
}
复制代码

想来这也是一个非常正常的需求,秤可以称各种水果的重量,但也可以只称苹果。你不能因为我只买苹果就不给我称重吧。所以把上面的代码加上上界通配符就可以啦。

List<Apple> apples = new ArrayList<>();
apples.add(new Apple());
float totalWeight = getTotalWeight(apples);
// 👆 不再报错
// 👇 增加了上界通配符 ? extends
private float getTotalWeight(List<? extends Fruit> fruitList) {
float totalWeight = 0;
for (Fruit fruit : fruitList) {
totalWeight += fruit.getWeight();
}
return totalWeight;
}
复制代码

不过,上面使用 ? extends 上界通配符突破了一层限制,却被施加了另一层限制:只可输出不可输入

什么意思呢?

比如:

List<Apple> apples = new ArrayList<Apple>();
List<? extends Fruit> fruits = apples;
Fruit fruit = fruits.get(0);
fruits.add(new Apple());
// 👆 报错:Required type: capture of ? extends Fruit Provided: Apple
复制代码

声明了上界通配符泛型的集合,不再允许 add 新的对象,Apple 不行,Fruit 也不行。拓展开来说:不止是集合,自己编写一个泛型做输入也不行

interface Shop<T> {
void showFruitName(T t);
T getFruit();
}

Shop<? extends Fruit> apples = new Shop<Apple>(){
@Override
public void showFruitName(Apple apple) { }

@Override
public Apple getFruit() {
return null;
}
};
apples.getFruit();
apples.showFruitName(new Apple());
// 👆 报错:Required type: capture of ? extends Fruit Provided: Apple
复制代码

泛型的下界通配符

泛型有上界通配符,那有没有下界通配符呢?

有的有的。

与上界通配符 ? extends 对应的就是下界通配符 ? super

下界通配符 ? super 所有情况和 ? extends 上界通配符刚刚相反:

  • 通配符 ? 表示 List 的泛型类型是一个 未知类型
  • super 限制了这个未知类型的下界,也就是泛型类型必须满足这个 super 的限制条件
    • 它的范围不仅是所有直接和间接子父类,还包括下界定义的子类本身。
    • super 同样支持 interface

它被施加的新限制是:只可输入不可输出

Shop<? super Apple> apples = new Shop<Fruit>(){
@Override
public void showFruitName(Fruit apple) { }

@Override
public Fruit getFruit() {
return null;
}
};
apples.showFruitName(new Apple());
Apple apple = apples.getFruit();
// 👆 报错:Required type: Apple Provided: capture of ? super Apple
复制代码

解释下,首先 ? 表示未知类型,编译器是不确定它的类型的。

虽然不知道它的具体类型,不过在 Java 里任何对象都是 Object 的子类,所以这里只能把apples.getFruit() 获取出来的对象赋值给 Object。由于类型未知,所以直接赋值给一个 Apple 对象肯定是不负责任的,需要我们做一层强制转换,不过强制转换本身可能发生错误。

 Apple 对象一定是这个未知类型的子类型,根据多态的特性,这里通过 showFruitName 输入 Button 对象是合法的。

小结下,Java 的泛型本身是不支持协变和逆变的:

  • 可以使用泛型通配符 ? extends 来使泛型支持协变,但是「只能读取不能修改」,这里的修改仅指对泛型集合添加元素,如果是 remove(int index) 以及 clear 当然是可以的。
  • 可以使用泛型通配符 ? super 来使泛型支持逆变,但是「只能修改不能读取」,这里说的不能读取是指不能按照泛型类型读取,你如果按照 Object 读出来再强转当然也是可以的。

理解了 Java 的泛型之后,再理解 Kotlin 中的泛型,就比较容易了。

0 个评论

要回复文章请先登录注册