Kotlin学习总结：函数的定义与调用（二）

Kotlin学习总结：函数的定义与调用（二）

给别人的类添加方法：扩展函数和属性

Kotlin的一大特色，就是可以平滑地与现有代码集成。甚至，纯Kotlin的项目都可以基于Java库构建，如JDK、Android框架，以及其他的第三方框架。当在一个现有的Java项目中集成Kotlin的时候，依然需要面临现有代码目前不能转成Kotlin，甚至将来也不会转成Kotlin的局面。可以使用扩展函数来实现使用这些API的时候，不需要重写，就能使用到Kotlin为它带来的方便。
理论上来说，扩展函数非常简单，它就是一个类的成员函数，不过定义在类的外面。添加一个方法，来计算一个字符串的最后一个字符：

package strings

fun String.lastChar(): Char = this.get(this.length - 1)

所有要做的，就是把要扩展的类或者接口的名称，放到即将添加的函数前面。这个类的名称被成为接收者类型；用来调用这个扩展函数的那个对象，叫作接收者对象。如图3.1所示。

图3.1 接收者类型是由扩展函数定义的，接收者对象是该类型的一个实例
可以像调用类的普通成员函数一样去调用这个函数：

>>> println("Kotlin".lastChar())
n

在这个例子中，String就是接收者类型，二“Kotlin”就是接收者对象。
从某种意义上说，已经为String类添加了自己的方法。即使字符串不是代码的一部分，也没有类的源代码，仍然可以在自己的项目中根据需要去扩展方法。不管String类是用Java、Kotlin，或者像Groovy的其他JVM语言编写的，只要是它会编译为Java类，就可以为这个类添加自己的扩展。
在这个扩展函数中，可以像其他成员变量函数一样用this。而且也可以像普通的成员函数一样，省略它。

package strings

fun String.lastChar(): Char = get(length - 1)	// 接收者对象成员可以不用this来访问

在扩展函数中，可以直接访问被扩展的类的其他方法和属性，就好像是在这个类自己的方法中访问它们一样。注意扩展函数并不允许打破它的封装性。和在类内部定义的方法不同的是，扩展函数不能访问私有的或者是受保护的成员。

导入和扩展函数

对于自定义的一个扩展函数，它不会自动地在整个项目范围内生效。相反，如果要使用它，需要进行导入，就像其他任何地类或者函数一样。这是为了避免偶然性地命名冲突。Kotlin允许用和导入类一样的语法来导入单个的函数：

import strings.lastChar

val c = "Kotlin".lastChar()

当然，用*来导入也是可以的：

import strings.*

val c = "Kotlin".lastChar()

可以使用关键字as来修改导入的类或者函数名称：

import strings.lastChar as last

val c = "Kotlin:.last()

当在不同的包中，有一些重名的函数时，在导入时给它重新命名就显得很有必要了，这样可以在同一个文件中去使用它们。在这种情况下，对于一般的类和函数，还有另一个选择：可以选择用全名来指出这个类或者函数。对于扩展函数，Kotlin的语法要求你用简短的名称，所以，在导入声明的时候，关键字as就是你解决命名冲突问题的唯一方式。

从Java中调用扩展函数

实质上，扩展函数是静态函数，它把调用对象作为了它的第一个参数。调用扩展函数，不会创建适配的对象或者任何运行时的额外消耗。
这使得从Java中调用Kotlin的扩展函数变得非常简单：调用这个静态函数，然后把接收者对象作为第一个参数传进去即可。和其他顶层函数一样，包含这个函数的Java类的名称，是由这个函数声明的文件名称决定的。假设它声明在一个叫作StringUtil.kt的文件中:

/* Java */
char c = StringUtilKt.lastChar("Java");

这个扩展函数被声明为顶层函数，所以，它将会被编译为一个静态函数。在Java中静态导入lastChar函数，就可以直接使用它了，如lastChar(“Java”)。和Kotlin版本比较起来，这个写法显得可读性略微差一点，但从Java的角度来看，这个也很正常。

作为扩展函数的工具函数

现在，可以写一个joinToString函数的终极版本了，它将和在Kotlin标准库中看到的一模一样。
声明扩展函数joinToString()：

fun <T> Collection<T>.joinToString( // 为Collection<T>声明一个扩展函数
    /* 有默认值的参数 */
    separator: String = ", ",
    prefix: String = "",
    postfix: String = ""
): String {
    val result = StringBuilder(prefix)

    for ((index, element) in this.withIndex()){ // this指向接收者对象：T的集合
        if (index > 0) result.append(separator)
        result.append(element)
    }

    result.append(postfix)
    return result.toString()
}

可以给元素的集合类添加一个扩展函数，然后给所有的参数添加一个默认值。这样就可以像使用一个类的成员函数一样，去调用joinToString了：

>>> val list = arrayListOf(1, 2, 3)
>>> println(list.joinToString(" "))
1 2 3

因为扩展函数无非就是静态函数的一个高校的语法糖，可以使用更具体的类型来作为接收者类型，而不是一个类。假如想要一个join函数，只能由字符串的集合来触发。

fun Collection<String>.join( 
    separator: String = ", ",
    prefix: String = "",
    postfix: String = ""
) = joinToString(separator, prefix, postfix)

>>> println(listOf("one", "two", "eight").join(" "))
one two eight

如果是用其他类型的对象列表来调用，将会报错：

>>> listOf(1, 2, 8).join()
Error: Type mismatch: inferred type is List<Int> but Collection<String> was expected.

扩展函数的静态性质也决定了扩展函数不能被子类重写。

不可重写的扩展函数

在Kotlin中，重写成员函数是很平常的一件事情。但是，不能重写扩展函数。假设这里有两个类，view和它的子类Button，然后Button重写了父类的click函数。
重写成员函数：

open class View {
    open fun click() = println("View clicked")
}

class Button : View() { // Button继承View
    override fun click() = println("Button clicked")
}

当声明了类型为View的变量，那它可以被赋值为Button类型的对象，因为Button是View的一个子类。当在调用这个变量的一般函数，比如click的时候，如果这个函数被Button重写了，那么这里将会调用到Button中重写的函数：

val view: View = Button()
view.click()    // 具体调用哪个方法，由实际的view的值来决定
Button clicked    

但是对于扩展函数来说，并不是这样的，如图3.2所示。

图3.2扩展函数声明在类的外部
扩展函数并不是类的一部分，它是声明在类之外的。它是由该变量的静态类型所决定的，而不是这个变量的运行时类型。
下面的例子就展示了两个分别声明在View和Button的showOff扩展你函数。
不能重写扩展函数：

fun View.showOff() = println("I'm a view!")
fun Button.showOff() = println("I'm a button!")

>>> val view: View = Button()
>>> view.showOff()  // 扩展函数被静态的解析
I'm a view!

当在调用一个类型为View变量的showOff函数时，对应的扩展函数会被调用，尽管实际上这个变量现在是一个Button的对象。
扩展函数并不存在重写，因为Kotlin会把它们当作静态函数对待。

---

注意，如果一个类的成员函数和扩展函数有相同的签名，成员函数往往会被优先使用。应该牢记，当在扩展API类的时候：如果添加一个和扩展函数同名的成员函数，那么对应类定义的消费者将会重新编译代码，这将会改变它的意义并开始指向新的成员函数。

---

扩展属性

扩展属性提供了一种方法，用来扩展类的API，可以用来访问属性，用的是属性语法而不是函数的语法。尽管它们被成为属性，但它们可以没有任何状态，因为没有合适的地方来存储它，不可能给现有的Java对象的实例添加额外的字段。但有时短语法仍然是便于使用的。
声明一个扩展属性：

val String.lastChar: Char
    get() = get(length - 1)

可以看到，和扩展函数一样，扩展属性也像接收者的一个普通的成员属性一样。这里，必须定义getter函数，因为没有支持字段，因此没有默认getter的实现。同理：初始化也不可以：因为没有地方存储初始值。
如果在StringBuilder上定义一个相同的属性，可以置为var，因为StringBuilder的内容是可变的。

var StringBuilder.lastChar: Char
    get() = get(length - 1)	// getter属性
    set(value) {
        this.setCharAt(length - 1, value)	// setter属性
    }

可以像访问使用成员属性一样访问它：

>>> println("Kotlin".lastChar)
n
>>> val sb = StringBuilder("Kotlin?")
>>> sb.lastChar = '!'
>>> println(sb)
Kotlin!

`
可以像访问使用成员属性一样访问它：

>>> println("Kotlin".lastChar)
n
>>> val sb = StringBuilder("Kotlin?")
>>> sb.lastChar = '!'
>>> println(sb)
Kotlin!

注意，当需要从Java中访问扩展属性的时候，应该显式地调用它的getter函数：StringUtilKt.getLastChar("Java)。