kotlin 系列文章均以 Java 差异为核心进行提炼,与 Java 相同部分不再列出。随着 kotlin 官方版本的迭代,文中有些语法可能会发生变化,请务必留意。
kotlin 泛型(generics)
与 java 一样,kotlin 的泛型用来表示变量类型的参数化。一个简单的范型类定义使用样例:
class Generics<T>(t: T) {
var tmp: T = t
}
/**
运行结果:
class java.lang.String
class cn.yan.test.Generics
class java.lang.String
class cn.yan.test.Generics
*/
fun testRun() {
val generics: Generics = Generics("666")
println(generics.tmp.javaClass)
println(generics.javaClass)//不像 java 没有<>就是 Object,kotlin 这里可以自动依据构造参数类型推断出是 String 类型val generics1 = Generics("666")
println(generics1.tmp.javaClass)
println(generics1.javaClass)
}
一个简单的范型函数定义如下:
//范型函数的定义声明
fun get(t: T): T = t
/**
调用
*/
fun testRun() {
val v1 = get("1233")val v2 = get<Int>(12)val v3 = get("1233") //等价于v1,自动推断
}
泛型约束之协变(covariant)与逆变(controvariant)
关于泛型协变与逆变概念其实来自 java,在我们深入搞懂 kotlin 的范型之前,我们有必要先巩固下 java 的范型协变与逆变。以 java 代码为例子:
//【工匠若水 加微信 yanbo373131686 联系我,关注微信公众号:码农每日一题 未经允许严禁转载 https://blog.csdn.net/yanbober】
//java 代码
//表示可以往这个范型集合放置任何类型对象
List//表示可以往这个范型集合只能放置String对象
List//在 java 中不能把 List 类型变量赋值给 List,因为他们不是父子类关系
List list1 = new ArrayList();//假设如果这么做被允许,则我们做如下代码,list2.add(new Date()); String str = list.get(0); 这会导致类型转换异常。
List list2 = list1; //编译失败
我们知道,在 java 中为了解决上面赋值问题,其提供了类型通配符的概念。如下是一个 java 样例:
//java 代码
//表示我们可以给这个变量里面 add Object 类型成员或者 Object 子类类型成员。
List extends Object> list;
我们继续看一种 java 场景:
//【工匠若水 加微信 yanbo373131686 联系我,关注微信公众号:码农每日一题 未经允许严禁转载 https://blog.csdn.net/yanbober】
//java 代码
interface Collection<E> {
void addAll(Collection items);
}
void addAll(Collection to, Collection from) {
//理论上我们觉得 String 可以赋值给 Object,但是普通范型中他们没有直接关系。
//无法编译通过,因为尝试赋值和接收的不是一个类型也不是父子类型关系。
to.addAll(from);
}
通过 java 对上面案例的改进写法如下 java 案例:
//java 代码
interface Collection<E> {
void addAll(Collection extends E> items);
}
void addAll(Collection to, Collection from) {
//通配符保证了编译通过,也可以安全的从 to 中读取元素,然后当作 Object 类型来使用。
to.addAll(from);
}
通过上面例子可以发现,java 中Collection
是Collection extends Object>
的子类型,但不是Collection
的子类型。? extends
用来限定类型的上界,也就是常说的协变,我们只能把它当作 extends 后面的 E 类型来读取,且读取是安全的类型转换,但是不能写入,写入会导致编译错误,因为写入可能是不安全的类型转换。反之,? super
用来限定类型的下界,也就是常说的逆变,逆变是用来保证写入安全的,但是不能读取,有可能类型是不安全的转换。
我们如果只从中读取数据而不写入内容则称为协变,如果只向里面写入数据而不读取数据则称为逆变。
有了上面 java 范型协变逆变的概念,现在我们再来看看 kotlin 的范型。如下 kotlin 案例:
//【工匠若水 加微信 yanbo373131686 联系我,关注微信公众号:码农每日一题 未经允许严禁转载 https://blog.csdn.net/yanbober】
class Generics<T>(t: T) {
private var tmp: T = t
fun get(): T = this.tmp
}
/**
运行结果:
test
*/
fun testRun() {
val t1 = Generics("test")val t2: Generics = t1
println(t2.get())//编译报错 Type mismatch. Required: Generics Found: Generics//val t3: Generics = t2
}
上面代码如果 t3 想编译通过需要修改代码为如下:
//kotlin 协变用 out 表示只能读取不能写入
class Generics<out T>(t: T) {
private var tmp: T = t
fun get(): T = this.tmp
//编译错误 参数 t 爆红 Type parameter T is declared as 'out' but occurs in 'in' position in type T
//fun set(t: T) = this.tmp = t
}
/**
运行结果:
test
test
*/
fun testRun() {
val t1 = Generics("test")val t2: Generics = t1
println(t2.get())val t3: Generics = t2
println(t3.get())
}
如上就能保证 t3 类型安全读取,但是可以看到 Generics 中的 set 方法是无法编译通过的,因为 T 是 out 的,只能读取不能当参数写入,所以要想写入得对上面代码改为如下:
//【工匠若水 加微信 yanbo373131686 联系我,关注微信公众号:码农每日一题 未经允许严禁转载 https://blog.csdn.net/yanbober】
//kotlin 协变用 out 表示只能读取不能写入
//kotlin 逆变用 in 表示只能写入不能读取
class Generics<out T, in M>(t: T, m: M) {
private var tmp: T = t
private var mm: M = m
fun get(): T = this.tmp
fun set(arg: M) {
this.mm = arg
}
}
fun testRun() {
val t1 = Generics("test", 12)val t2: Generics = t1
t2.get()
t2.set(12)val t3: GenericsInt> = t2
t3.get()
t3.set(12)
}
如上代码体现的都是 kotlin 声明处协变和逆变的场景。
kotlin 泛型类型投影
由于 koltin 声明处协变逆变导致类型只能被读或者只能被写,不能读写操作。要想能同时读写就需要用到使用处协变逆变,也就是kotlin 类型投影。我们先看一个又想读也想写的例子,这个例子使用了 kotlin 的 Array 范型,所以先看下其源码:
//kotlin 中的 Array.kt 源码
//由于 T 即被读也被写,所以如果按照 koltin 声明处协变规则来说,这里即不能加 in 也不能加 out
public class Array<T> {
//对T的读取
public operator fun get(index: Int): T
//对T的写入
public operator fun set(index: Int, value: T): Unit
}
接着我们使用它来一步步做到既能读也能写的能力,如下:
//【工匠若水 加微信 yanbo373131686 联系我,关注微信公众号:码农每日一题 未经允许严禁转载 https://blog.csdn.net/yanbober】
fun copy(from: Array<Any>, to: Array<Any>) {
assertEquals(from.size, to.size)
for (index in from.indices) {
to[index] = from[index]
}
}
/**
输出结果:
hello0
hello1
*/
fun testRun() {
val from: Array<Int> = arrayOf(1, 2)
val to: Array = Array(2) { it -> "hello$it" }
to.forEach { println(it) }//编译报错 Type mismatch. Required: Array Found: Array//copy(from, to)
}
上面例子如果想要编译及运行通过就需要使用 kotlin 提供的类型投影机制,如下案例:
//这个 out 没在声明处,是在定义方法的地方
fun copy(from: Array<out Any>, to: Array<Any>) {
assertEquals(from.size, to.size)
for (index in from.indices) {
to[index] = from[index]
//编译报错,只能从 from 读,不能写入
//form[index] = 1
}
}
/**
输出结果:
hello0
hello1
*/
fun testRun() {
val from: Array<Int> = arrayOf(1, 2)
val to: Array = Array(2) { it -> "hello$it" }
to.forEach { println(it) }
copy(from, to)
}
kotlin 泛型星投影
如果Base
里面 T 的上界是 TUpper,那么Base
就相当于Base
,这表示当 T 的类型未知时,你可以安全的从Base
中读取TUpper类型的值。
如果Base
里面 T 的下界是 TUpper,那么Base
就相当于Base
,Nothing 在 kotlin 中表示什么都不存在,所以无法向Base
中写入任何类型的值。
如果Base
里面 T 的上界是 TUpper,那么Base
就相当于读取时的Base
以及写入时的Base
。
如下是上面说法的验证实例:
//【工匠若水 加微信 yanbo373131686 联系我,关注微信公众号:码农每日一题 未经允许严禁转载 https://blog.csdn.net/yanbober】
class Base<out T>
class Base2<in T> {
fun set(t: T) {
}
}
class Base3<T> (var t: T) {
fun set(t: T) {
this.t = t
}
fun get(): T = this.t
}
/**
测试使用
*/
fun testRun() {
val base1: Base = Base<Int>()val base1a: Base = base1val base2: Base2<Int> = Base2()
base2.set(1)val base2a: Base2 = base2//编译报错 Out-projected type 'Base2' prohibits the use of 'public final fun set(t: T): Unit defined in cn.yan.test.Base2'//base2a.set(3)val base3: Base3<Int> = Base3<Int>(12)
base3.set(1)
base3.get()val base3a: Base3 = base3
base3a.get()//编译报错 Out-projected type 'Base3' prohibits the use of 'public final fun set(t: T): Unit defined in cn.yan.test.Base3'//base3a.set(12)
}
上面案例就是 kotlin 范型星投影的诠释。
kotlin 泛型擦除
在 jvm 平台下的 kotlin 与 java 类似,由于遵守 jvm 规范,所以对于范型也存在擦除特性,所以 kotlin 语法层面的范型检查有些时候是可以绕过的,因为本质到字节码层面都被擦除了。如下案例:
class Base<out T> (private var t: T) {
fun get(): T = this.t
//无法编译通过,因为 T 是 out 的,只能读不能写
//fun set(t: T) { this.t = t }
//kotlin 允许 @UnsafeVariance 注解来保证编译通过及能使用,但是安全不保证
fun set(t: @UnsafeVariance T) {
this.t = t
}
}
/**
输出结果:
12
xxxxx
*/
fun testRun() {
val base1: Base = Base<Int>(12)
println(base1.get())//因为@UnsafeVariance的存在,这里可以写操作
base1.set("xxxxx") //范型擦除,所以可以存储,本质在字节码都是 Object,类似 java 范型擦除
println(base1.get())
}
到此暂时告一段落。
小编 朋友圈技术更精彩>
▼往期精彩回顾▼听说你精通 kotlin 函数与 lambada 表达式?kotlin 面向对象 360 度无死角覆盖!!点击左下角阅读原文查看历史经典技术问题汇总,看完顺手一键三连呀~