Kotlin泛型笔记
Kotlin语言基础笔记
Kotlin流程控制语句笔记
Kotlin操作符重载与中缀表示法笔记
Kotlin扩展函数和扩展属性笔记
Kotlin空指针安全(null-safety)笔记
Kotlin类型系统笔记
Kotlin面向对象编程笔记
Kotlin委托(Delegation)笔记
Kotlin泛型型笔记
Kotlin函数式编程笔记
Kotlin与Java互操作笔记
Kotlin协程笔记
Kotlin中的泛型跟Java中的泛型基本上一样,都是在编译的时候才有效果,在运行期是擦除的。我们可以在类,方法中使用泛型:
class Box<T>(var value: T){
fun get(): T {
return value
}
fun set(x: T){
this.value = x;
}
}
fun <T> newBox(value: T) = Box(value)
fun main(args: Array<String>) {
val box1:Box<String> = Box<String>("Denny")
val box2:Box<String> = Box("Denny")
val box3 = Box("Denny")
val box5 = newBox(true)
val box4 = Box(1)
box4.set("Jack") //编译错误。Type mismatch, Required: Int, Found String
}
泛型类的定义是在类名称之后主构造函数之前,泛型函数声明跟Java一样,类型参数要放在函数明之前。类型如果可以推断出来的话,可以省略泛型类型。
泛型函数类型参数可以使用:
冒号指定上界:
fun <T : Comparable<T>> sort(list: List<T>){...}
如果有多个上界,可以使用where
语句。
fun <T> cloneWhenGreater(list: List<T>, threshold: T): List<T>
where T : Comparable, Cloneable {
return list.filter(it > threshold).map(it.clone())
}
1. 协变(covariant)和逆变(contravariant)
Number[] numbers = new Integer[]{1, 2, 3}; //works
List<Number> numberList = new ArrayList<Integer>(); //编译错误,暴类型不兼容错误。
Java中,数组是协变的,而泛型不是协变的,也就是说Integer是Number的子类,数组类型Integer[]也是Number[]的子类,但是List<Integer>不是List<Number>的子类。
Animal类型是Dog类型的父类,假如Animal类型标记为F(father),Dog类型标记为C(child),我们用这个表示父子类型关系:F <| C。而对应的泛型List<Animal>,List<Dog>,我们标记为f<F>, f<C>。那么当 F <| C时:
- 如果f<F> <| f<C>成立,那么f叫做协变;
- 如果f<C> <| f<F>成立,那么f叫着逆变;
- 如果以上两种情况都不成立,那么叫着不可变;
Java的泛型是不变的。如果要实现协变和逆变的话,那么我们就需要使用通配符?
。
<? extends T>
实现了泛型的协变
List<? extends Number> list1 = new ArrayList<Integer>();
List<? extends Number> list2 = new ArrayList<Float>();
以上便实现了协变,但是你要注意的是,这里的list1和list2只能够add(null),不能够添加其他任意对象。如下:
为什么会这样呢?因为如果List<? extends Number> 可以添加Integer,Float,Double等数字类型的话,那么从这个List获取到的值可能会有各种类型,也就会引发潜在的错误,所以Java为了保护类型一致性,就禁止向List<? extends Number> 添加任意对象。
<? super T>实现了泛型的逆变
List<? super Number> list3 = new ArrayList<Number>();
List<? super Number> list4 = new ArrayList<Object>();
list3.add(new Integer(3));
list4.add(new Float((3.3)));
我们可以向List<? super Number>添加Number以及Number的子类,但是不能添加Number的父类。
image.png
PECS
PECS: producer-extends,consumer-super
也就是说生产者使用extends,消费者使用super。具体可以看看java.util.Collections#copy
方法:
public static <T> void copy(List<? super T> dest, List<? extends T> src) {
int srcSize = src.size();
if (srcSize > dest.size())
throw new IndexOutOfBoundsException("Source does not fit in dest");
if (srcSize < COPY_THRESHOLD ||
(src instanceof RandomAccess && dest instanceof RandomAccess)) {
for (int i=0; i<srcSize; i++)
dest.set(i, src.get(i));
} else {
ListIterator<? super T> di=dest.listIterator(); // in T, 写入dest数据
ListIterator<? extends T> si=src.listIterator(); // out T, 读取src数据
for (int i=0; i<srcSize; i++) {
di.next();
di.set(si.next());
}
}
}
2. Kotlin中的泛型
Kotlin中的泛型使用的正是前面说的PECS(生产者消费者)概念,在上面说到的java.util.Collections#copy
方法中:
-
List<? extends T> src
是生产者,也就是数据提供者,在Kotlin中叫out T
。生产者不能写入数据,只能读取。 -
List<? super T> dest
是消费者,也就是吞掉一些数据,或者说会有数据写入到该对象中,在Kotlin中叫in T
,消费者可以写入T或者T的子类。
在Kotlin中,我们把那些只能保证读取数据时类型安全的对象叫做生产者,用 out T标记;把那些只能保证写入数据安全时类型安全的对象叫做消费者,用 in T标记。
2.1 声明处型变
Kotlin对Java泛型最大的改动就是增加了声明处型变,下面的例子:
interface Source<T> {
T nextT();
}
void demo(Source<String> str) {
// Java 中这种写法是不允许的
Source<Object> obj = str;
/*...*/
}
因为Java泛型不可型变的,所以Source<String>不是Source<Object>的子类。但是在Kotlin中你就能做到,用Kotin改写下:
interface Source<out T>{
fun nextT() : T
}
fun demo(str: Source<String>) {
val obj:Source<Any> = str //works
}
因为Source这个接口只有一个读取数据的方法,可以视为生产者,所以把这个接口的类型参数声明为生产者后,就可以实现安全的类型协变了。Kotlin中有大量的声明处协变,比如:Iterable接口声明:
public interface Iterable<out T> {
/**
* Returns an iterator over the elements of this object.
*/
public operator fun iterator(): Iterator<T>
}
因为Collection和Map接口都继承了Iterable接口,而Iterable被声明成了生产者(out T
)。所以Collection和Map以及子类都可以实现安全的类型协变:
val c: List<Number> = listOf(1, 2, 3)
2.2 类型投影
类似Java中的无界类型通配符?
, Kotlin 也有对应的星投影语法*
。
例如,如果类型被声明为 interface Function <in T, out U>,我们有以下星投影:
-
Function<*, String>
表示Function<in Nothing, String>
; -
Function<Int, *>
表示Function<Int, out Any?>
; -
Function<*, *>
表示Function<in Nothing, out Any?>
;
*
投影跟 Java 的原始类型类似,不过是安全的。