文档结构  
翻译进度:已翻译     翻译赏金:0 元 (?)    ¥ 我要打赏

Kotlin 同 C# 和 Gosu 类似,能够扩展一个类的新功能而无需继承该类或使用像装饰者这样的任何类型的设计模式。 这通过叫做_扩展_的特殊声明完成。Kotlin 支持_扩展函数_ 和 扩展属性

扩展函数

声明一个扩展函数,我们需要用一个 接收者类型 也就是被扩展的类型来作为他的前缀。 下面代码为 MutableList<Int> 添加一个swap 函数:

fun MutableList<Int>.swap(index1: Int, index2: Int) {
    val tmp = this[index1] // 'this' corresponds to the list
    this[index1] = this[index2]
    this[index2] = tmp
}
第 1 段(可获 0.96 积分)

这个 this 关键字在扩展函数内部对应到接收者对象(传过来的在点符号前的对象) 现在,我们对任意 MutableList<Int> 调用该函数了:

val l = mutableListOf(1, 2, 3)
l.swap(0, 2) // 'this' inside 'swap()' will hold the value of 'l'

当然,这个函数对任何 MutableList<T> 起作用,我们可以泛化它:

fun <T> MutableList<T>.swap(index1: Int, index2: Int) {
    val tmp = this[index1] // 'this' corresponds to the list
    this[index1] = this[index2]
    this[index2] = tmp
}

为了在接收者类型表达式中使用泛型,我们要在函数名前声明泛型参数。 参见泛型函数

第 2 段(可获 0.83 积分)

扩展是静态解析的

扩展不能真正的修改他们所扩展的类。通过定义一个扩展,你并没有在一个类中插入新成员, 仅仅是可以通过该类型的变量用点表达式去调用这个新函数。

我们想强调的是扩展函数是静态分发的,即他们不是根据接收者类型的虚方法。 这意味着调用的扩展函数是由函数调用所在的表达式的类型来决定的, 而不是由表达式运行时求值结果决定的。例如:

open class C

class D: C()

fun C.foo() = "c"

fun D.foo() = "d"

fun printFoo(c: C) {
    println(c.foo())
}

printFoo(D())
第 3 段(可获 1.2 积分)

这个例子会输出 "c",因为调用的扩展函数只取决于 参数 c 的声明类型,该类型是 C 类。

如果一个类定义有一个成员函数和一个扩展函数,而这两个函数又有相同的接收者类型、相同的名字 并且都适用给定的参数,这种情况总是取成员函数。 例如:

class C {
    fun foo() { println("member") }
}

fun C.foo() { println("extension") }
第 4 段(可获 0.73 积分)

如果我们调用 C 类型 c的 c.foo(),它将输出“member”,而不是“extension”。

当然,扩展函数重载同样名字但不同签名成员函数也完全可以:

class C {
    fun foo() { println("member") }
}

fun C.foo(i: Int) { println("extension") }

调用 C().foo(1) 将输出 "extension"。

可空接收者

注意可以为可空的接收者类型定义扩展。这样的扩展可以在对象变量上调用, 即使其值为 null,并且可以在函数体内检测 this == null,这能让你 在没有检测 null 的时候调用 Kotlin 中的toString():检测发生在扩展函数的内部。

第 5 段(可获 1.2 积分)
fun Any?.toString(): String {
    if (this == null) return "null"
    // after the null check, 'this' is autocast to a non-null type, so the toString() below
    // resolves to the member function of the Any class
    return toString()
}

扩展属性

和函数类似,Kotlin 支持扩展属性:

val <T> List<T>.lastIndex: Int
    get() = size - 1

注意:由于扩展没有实际的将成员插入类中,因此对扩展属性来说 幕后字段是无效的。这就是为什么扩展属性不能有 初始化器。他们的行为只能由显式提供的 getters/setters 定义。

第 6 段(可获 0.69 积分)

示例:

val Foo.bar = 1 // error: initializers are not allowed for extension properties

伴生对象的扩展

如果一个类定义有一个伴生对象 ,你也可以为伴生对象定义 扩展函数和属性:

class MyClass {
    companion object { }  // will be called "Companion"
}

fun MyClass.Companion.foo() {
    // ...
}

就像伴生对象的其他普通成员,只需用类名作为限定符去调用他们

MyClass.foo()

扩展的作用域

大多数时候我们在顶层定义扩展,即直接在包里:

第 7 段(可获 0.79 积分)
package foo.bar
 
fun Baz.goo() { ... } 

要使用所定义包之外的一个扩展,我们需要在调用方导入它:

package com.example.usage

import foo.bar.goo // importing all extensions by name "goo"
                   // or
import foo.bar.*   // importing everything from "foo.bar"

fun usage(baz: Baz) {
    baz.goo()
)

更多信息参见导入

扩展声明为成员

在一个类内部你可以为另一个类声明扩展。在这样的扩展内部,有多个 隐式接收者 —— 其中的对象成员可以无需通过限定符访问。扩展声明所在的类的实例称为 分发接收者,扩展方法调用所在的接收者类型的实例称为 扩展接收者 。

第 8 段(可获 1.09 积分)
class D {
    fun bar() { ... }
}

class C {
    fun baz() { ... }

    fun D.foo() {
        bar()   // calls D.bar
        baz()   // calls C.baz
    }

    fun caller(d: D) {
        d.foo()   // call the extension function
    }
}

对于分发接收者和扩展接收者的成员名字冲突的情况,扩展接收者 优先。要引用分发接收者的成员你可以使用 限定的 this 语法

class C {
    fun D.foo() {
        toString()         // calls D.toString()
        this@C.toString()  // calls C.toString()
    }
第 9 段(可获 0.46 积分)

声明为成员的扩展可以声明为 open 并在子类中覆盖。这意味着这些函数的分发 对于分发接收者类型是虚拟的,但对于扩展接收者类型是静态的。

open class D {
}

class D1 : D() {
}

open class C {
    open fun D.foo() {
        println("D.foo in C")
    }

    open fun D1.foo() {
        println("D1.foo in C")
    }

    fun caller(d: D) {
        d.foo()   // call the extension function
    }
}

class C1 : C() {
    override fun D.foo() {
        println("D.foo in C1")
    }

    override fun D1.foo() {
        println("D1.foo in C1")
    }
}

C().caller(D())   // prints "D.foo in C"
C1().caller(D())  // prints "D.foo in C1" - dispatch receiver is resolved virtually
C().caller(D1())  // prints "D.foo in C" - extension receiver is resolved statically
第 10 段(可获 0.48 积分)

动机

在Java中,我们将类命名为“*Utils”:FileUtilsStringUtils 等,著名的 java.util.Collections 也属于同一种命名方式。 关于这些 Utils-类的不愉快的部分是代码写成这样:

// Java
Collections.swap(list, Collections.binarySearch(list, Collections.max(otherList)), Collections.max(list))

这些类名总是碍手碍脚的,我们可以通过静态导入达到这样效果:

// Java
swap(list, binarySearch(list, max(otherList)), max(list))

这会变得好一点,但是我们并没有从 IDE 强大的自动补全功能中得到帮助。如果能这样就更好了:

// Java
list.swap(list.binarySearch(otherList.max()), list.max())

这会变得好一点,但是我们并没有从 IDE 强大的自动补全功能中得到帮助。如果能这样就更好了:

第 11 段(可获 1.31 积分)

文章评论