Java泛型与Kotlin泛型

正文

本文主要列举Java泛型与Kotlin泛型的基本知识,以及两者的区别。

什么泛型

泛型程序设计是程序设计的一种风格或或规范。简单的说就是该类型可变,在编写代码时可以根据情况设置不同的类型。因为泛型的可变性,很容易出现类型转换异常,Java与Kotlin在编译期间提供了泛型检测,帮助开发者在编译期间就能尽量避免此异常的出现。

Java泛型的基本知识

Java泛型主要用在类,接口,类方法。泛型仅在编译期间有效,编译完成后擦除泛型标记。

// 类
class ObjectA<T>{}
// 接口
interface InterfaceB<T>{}
// 方法
private <T> void fill(ArrayList<T> numbers) {}

泛型具有子类自动强转父类的功能,符合设计模式的里氏替换原则,例如:

class Parent{}

class Child extends Parent{}

// 指定泛型为Parent
ObjectA<Parent> o = new ObjectA<Parent>();
// 允许接收Parent的子类
o.add(new Child());

尽管泛型可以使用子类的类型,但是并不代表使用泛型的对象具有泛型的继承关系,例如:

private void fill(ObjectA<Parent> obj){}

fill(new ObjectA<Parent>(););
// 该行代码会报错,错误提示为:Child不能转换为Parent
fill(new ObjectA<Child>());

由此可见泛型仅仅是提供了对象的类型判断而已,无法自动型变。

我们还可以限制泛型的范围,例如:

class ObjectA<T extends Parent>{
    public void add(T t){}
}

通过extends关键字表示,泛型只可以为Parent以及他的子类,设置其他泛型报错。通常情况下,extends可以缺省,例如:

class ObjectA<Parent>{}
class ObjectA<T extends Parent>{}

因为刚才我们提到了泛型具有自动向上强转的特性,所以两种代码作用相同,但是语义来看,extends的语义更强。但是某些情况下,设置了extends会有明显的不同,例如:

ArrayList<Parent> parents1 = new ArrayList<>();
ArrayList<? extends Parent> parents2 = new ArrayList<>();

parents1.add(new Parent());
// 注意!!此行代码会报错
parents2.add(new Parent());
        
Parent p1 = parents1.get(0);
Parent p2 = parents2.get(0);

?是Java泛型中的通配符,表示任何的类型。在指定泛型的时候,如果使用了extends关键字,表示集合内部只能添加Parent以及它的子类,但是Parent的子类我们只能选择一个,例如Parent有三个子类A,B,C,我们只能选择其中一个,但是具体是哪一个只能在运行中才能知道,所以Java干脆限制只能获取,不能添加。

与extends相对应的还有super关键字,它表示只能添加,而读取的类型是Object:

// suer关键字表示只可以输入Child以及它的父类
ArrayList<? super Child> children= new ArrayList<>();
children.add(new Child());
// 注意!!此行代码会报错
// Child child= children.get(0);
Child child= (Child) children.get(0);

很多资料都说super表示泛型为Child的父类,但是实际使用中并不是这样,他仍然是Child以及它的子类,因为所有类型的基类都是Object,那么super关键字就失去了意义,可能是因为这样的原因,super的作用目前与extends的范围一致,但是设计的思想是相反的,所以获取数据只能得到Object。

由此可以总结,extends限制的是输出类型的上限,super限制的输入类型下限。

Kotlin泛型与Java泛型的差异

Kotlin泛型与Java泛型大部分都是相同的,但是语言特性导致有部分差异。

一、Java泛型不可调用泛型的方法,Kotlin可以

// Java语法不可以直接调用泛型T的方法
private <T> void fill(ArrayList<T> numbers) {}
// Kotlin通过内联机制,可以使用泛型T的方法
inline fun <reified T> printGenerality(data: T) {
    println(T::class.java)
}

原因分析:泛型只在编译期间有效,运行期间会被擦除,所以泛型信息会消失,Java基于栈的形式调用方法得不到泛型的具体类型,Kotlin通过内联机制,编译期间是把方法直接添加到了对应的代码中,不存在栈调用的问题,所以可以通过上下文推导出泛型的具体类型。

友情提示:内联方法慎用return,会导致调用方直接返回。

二、Kotlin的泛型的型变

以之前的Java代码为例:

private void fill(ObjectA<Parent> obj){}

fill(new ObjectA<Parent>(););
// 该行代码会报错,错误提示为:Child不能转换为Parent
fill(new ObjectA<Child>());

虽然Child继承Parent,但是Java泛型无法推导出两者的继承关系,但是Kotlin的泛型可以:

val list1 = ArrayList<Number>()
val list2 = ArrayList<Double>()
fill(list1)
fill(list2)

private fun fill(list: List<Number>) {}

原因分析:Kotlin把泛型拆分为输入泛型和输出泛型,关键字为in和out,例如:

class ObjectA<in T, out E>(private val t: T, private val e: E) {  
    // 泛型T仅可以出现在输入方法,例如set
    fun set(t: T) {
        this.t = t
    }
    // 泛型E仅可以出现在输出方法,例如get
    fun get() = e
}

上面的代码指定了,泛型T为输入类型,表示T只能用在输入的位置,例如set方法,如果有getT方法则报错,泛型E规则与之相反。

Kotlin重写了List接口:

// 标记集合的类型为输出类型
public interface List<out E> : Collection<E> 

但是ArrayList则将泛型E既当做输入类型,也当做输出类型:

public class ArrayList<E> 

所以调用方法 fill(list: List<Number>)时,判断out泛型是否一致,而Double可以向上强转为Number,所以检查通过。

总结Koltin的泛型用in修饰,表示此泛型只可出现在输入位置,支持类型型变,泛型使用out修饰,表示此泛型只可以出现在输出位置,支持类型的逆变。

推荐阅读更多精彩内容