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)时，判断out泛型是否一致，而Double可以向上强转为Number，所以检查通过。

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