泛型

作者: 熹哥 | 来源:发表于2017-08-09 09:39 被阅读16次

1.kotlin和java一样支持类型参数:

class Box<T>(t: T) {
    var value = t
}

你可以像下面这样创建实例,你需要提供类型参数:

val box: Box<Int> = Box<Int>(1)

假如类型参数是可以推断的,比如根据构造函数的参数等等,类型参数是可以忽略的,如下所示:

val box = Box(1) // 1 has type Int, so the compiler figures out that we are talking about Box<Int>

2.型变

Java 类型系统中最棘手的部分之一是通配符类型,如果不了解java通配符的同学可以先了解 java通配符的使用,而在kotlin中没有通配符,为了解决java中遇到的问题,提出了另外两个东西:声明处型变(declaration-site variance)与类型投影(type projections)

3.声明处型变

声明处形变outin
out协变的类型参数示例:

open class Animal {
}
open class Suckler: Animal() {
}
class Dog: Suckler() {
}
class Source<out T> {
    fun get():T? {
        return null
    }

    //out 声明的类型参数不能作为参数传入,否则编译不通过
//    fun add(t: T) {
//
//    }

    //只能将Suckler或其子类赋值给t
    //好比我有一个只能往外取Suckler的箱子,你把这个箱子换成装Dog的箱子也是没问题的,因为你取出来的Dog可以当Suckler使用
    fun match(source: Source<Dog>) {
        var t: Source<Suckler> = source
//        val dog: Dog = t.get()
    }

    //out声明的泛型只能将String或者子类赋值给t,下面编译不通过
//    fun mismatch(tree: Source<Animal>) {
//        var t: Source<Dog> = tree
//    }
}
  • out修饰的类型参数是生产者如Source<out T>,只允许从source中返回T(即生产),而不能添加(作为参数传入)
  • 可以将子类赋值给父类
  • Array<out Any>相当于java的Array<? extends Object>

in:逆变的类型参数示例:

class Sink<in T> {
    fun add(t: T) {

    }

    //in修饰的类型参数不能返回,否则会编译不通过
//    fun get() : T? = null

    //只能将Suckler类型或其父类赋值给 t
    //好比我有一个只能往里面放Suckler的箱子,你把它换成可以装Animal的箱子也是没问题的,因为Suckler和Dog都可以往里面放
    fun match(sink: Sink<Animal>) {
        var t: Sink<Suckler> = sink
        t.add(Suckler())
        t.add(Dog())
//        t.add(Animal)
    }

    //编译不通过,报Type mismatch
//    fun dismiss(router: Sink<Suckler>) {
//        var t: Sink<Animal> = router
//    }
}
  • 和out相反in修饰的参数类型只能被消费(可以作为参数传入)而不可以被生产(返回)
  • 可以将父类赋值给子类
  • Array<in String> 相当于java的 Array<? super String>

4.使用处型变

考虑下面的问题:

class Array<T>(val size: Int) {
    fun get(index: Int): T { ///* …… */ }
    fun set(index: Int, value: T) { ///* …… */ }
}
fun copy(from: Array<Any>, to: Array<Any>) {
    assert(from.size == to.size)
    for (i in from.indices)
        to[i] = from[i]
}

这个函数应该将项目从一个数组复制到另一个数组。让我们尝试在实践中应用它:

val ints: Array<Int> = arrayOf(1, 2, 3)
val any = Array<Any>(3) { "" } 
copy(ints, any) // 错误:期望 (Array<Any>, Array<Any>)

我们可以在使用初形变解决这个问题:

fun copy(from: Array<out Any>, to: Array<Any>) {
 // ......
}

类型投影:这里的 from 不仅仅是一个数组,而是一个受限制的(投影 的)数组。
或者使用 in 做类型投影:

fun fill(dest: Array<in String>, value: String) {
    // ......
} 

Array<in String> 对应于 Java 的 Array<? super String> ,也就是说,你可以传递一个 CharSequence 数组或一个 Object 数组给 fill() 函数。

5. 星投影

class Bar<in T, out U>() {
    fun add(t: T) {

    }

    fun get(): U? {
        return null
    }
}

fun test0(bar: Bar<*, Suckler>) {
    //添加不了,因为我不知道你的类型是什么
//    bar.add(Animal())
}

fun test1(bar: Bar<Suckler, *>) {
    bar.add(Suckler())
    bar.add(Dog())

    bar.get()
}

fun test2(bar: Bar<*, *>) {
    //添加不了,因为我不知道你的类型是什么
//    bar.add(Animal())
    
    bar.get()
}

你对类型参数一无所知,但仍然希望以安全的方式使用它。 这里的安全方式是 定义泛型类型的这种投影,该泛型类型的每个具体实例化将是该投影的子类型。
星投影语法:
假设类型被声明 为 interface Function <in T, out U> ,我们可以想象以下星投影:

  • Function<*, String> 表示 Function<in Nothing, String> ;
  • Function<Int, *> 表示 Function<Int, out Any?> ;
  • Function<*, *> 表示 Function<in Nothing, out Any?>

6.泛型函数

fun <T> singletonList(item: T): List<T> {
    // ......
}
fun <T> T.basicToString() : String { // 扩展函数 
        // ......
}

val l = singletonList<Int>(1)

7.泛型约束

fun <T : Comparable<T>> sort(list: List<T>) {
    // ......
}

冒号之后指定的类型是上界:只有Comparable<T> 的子类型可以替代 T 。

8.具体化的类型参数

内联函数支持具体化的类型参数。下面看看我们不使用具体化的类型参数的情况:

fun <T> TreeNode.findParentOfType(clazz: Class<T>): T? {
    var p = parent
    while (p != null && !clazz.isInstance(p)) {
        p = p.parent
    }
    @Suppress("UNCHECKED_CAST")
    return p as T?
}

 treeNode.findParentOfType(MyTreeNode::class.java)

上面的代码使用了扩展函数的语法,如对扩展函数不熟悉,请查看扩展函数的语法。
让我们看看下面使用具体化的类型参数的例子:

inline fun <reified T> TreeNode.findParentOfType(): T? {
    var p = parent
    while (p != null && p !is T) {
        p = p.parent
    }
    return p as T?
}

myTree.findParentOfType<MyTreeNodeType>()

我们使用 reified 修饰符来限定类型参数,现在可以在函数内部访问它了, 几乎就像是一个 普通的类一样。由于函数是内联的,不需要反射,正常的操作符如 !is 和 as 现在都能用了。如对内联函数不熟悉,请查看内联函数的语法。

相关文章

  • 泛型 & 注解 & Log4J日志组件

    掌握的知识 : 基本用法、泛型擦除、泛型类/泛型方法/泛型接口、泛型关键字、反射泛型(案例) 泛型 概述 : 泛型...

  • 【泛型】通配符与嵌套

    上一篇 【泛型】泛型的作用与定义 1 泛型分类 泛型可以分成泛型类、泛型方法和泛型接口 1.1 泛型类 一个泛型类...

  • 泛型的使用

    泛型有三种使用方式,分别为:泛型类、泛型接口、泛型方法 泛型类 泛型接口 泛型通配符 泛型方法 静态方法与...

  • Java 泛型

    泛型类 例如 泛型接口 例如 泛型通配符 泛型方法 类中的泛型方法 泛型方法与可变参数 静态方法与泛型 泛型上下边...

  • 探秘 Java 中的泛型(Generic)

    本文包括:JDK5之前集合对象使用问题泛型的出现泛型应用泛型典型应用自定义泛型——泛型方法自定义泛型——泛型类泛型...

  • Web笔记-基础加强

    泛型高级应用 自定义泛型方法 自定义泛型类 泛型通配符? 泛型的上下限 泛型的定义者和泛型的使用者 泛型的定义者:...

  • 重走安卓进阶路——泛型

    ps.原来的标题 为什么我们需要泛型? 泛型类、泛型接口和泛型方法(泛型类和泛型接口的定义与泛型方法辨析); 如何...

  • Kotlin泛型的高级特性(六)

    泛型的高级特性1、泛型实化2、泛型协变3、泛型逆变 泛型实化 在Java中(JDK1.5之后),泛型功能是通过泛型...

  • Java 19-5.1泛型

    泛型类定义泛型类可以规定传入对象 泛型类 和泛型方法 泛型接口 如果实现类也无法确定泛型 可以在继承类中确定泛型:

  • 【Swift】泛型常见使用

    1、Swift泛型4种 泛型函数泛型类型泛型协议泛型约束 2、泛型约束3种 继承约束:泛型类型 必须 是某个类的子...

网友评论

      本文标题:泛型

      本文链接:https://www.haomeiwen.com/subject/grkmhxtx.html