扩展

Kotlin 可以无需依靠继承或某种设计模式（例如装饰器）来扩展一个类的功能，这点类似 C# 和 Gosu。这个能力通过一个叫 extensions 的特殊声明来实现。 Kotlin 支持扩展函数（extension functions）和扩展属性（extension properties）。

扩展函数

扩展函数的名字需要把接收者类型（被扩展的类型）作为前缀。下面的代码展示了如何给 MutableList<Int> 增加一个 swap 函数：

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

扩展函数的 this 关键字指向接收者对象（位于点号之前）。这样就可以调用任何 MutableList<Int> 的这个函数。

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

当然，这个函数对于任何 MutableList<T> 也是有意义的，所以可以让其更通用：

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

泛型参数的声明位于函数名之前，这样做的目的是为了让它在接收者类型表达式中可用。具体可见泛型函数。

扩展会被静态解析

扩展没有实际修改他们所扩展的类。定义扩展并没有给原有的类插入新的成员，只是通过点操作使得新的函数在这种类型的变量上变得可被调用。

需要强调的是，扩展函数的分发方式是静态的，也就是说，他们不是接收器类型的虚函数。这就意味着，被调用的扩展函数是由调用这个函数的表达式类型所决定，而不是由运行时得到的表达式的结果类型所决定。例如：

  1. open class C
  3. class D: C()
  5. fun C.foo() = "c"
  7. fun D.foo() = "d"
  9. fun printFoo(c: C) {
  10.     println(c.foo())
  11. }
  13. printFoo(D())

这个例子会打印出“c”，因为被调用的扩展函数只依赖于参数c所声明的类型，即 C 这个类。

如果成员函数的类和扩展函数的接收者类型一样，并且他们的名字和参数也都一样，那么优先级高的是成员函数。例如：

  1. class C {
  2.     fun foo() { println("memeber") }
  3. }
  5. fun C.foo() { println("extension") }

如果调用 c.foo()（任意 C 类型的变量 c），会打印出 “member”，而不是 “extension”。

但是，利用扩展函数去重载成员函数是完全OK的（函数名相同，但是函数签名不同）。

  1. class C {
  2.     fun foo() { println("member") }
  3. }
  5. fun C.foo(i: Int) { println("extension") }

调用 C().foo(1) 会打印出 “extension”。

可空的接收者

注意扩展定义在一个可空的接收者类型上。这种扩展可在对象变量上被调用，即使它的值为空，并且在函数体内可以检查 this == null。这也是为什么不做判空也可以调用 toString() 方法，因为检查已经在扩展函数中做掉了。

  1. fun Any?.toString(): String {
  2.     if (this == null) return "null"
  3.     // after the null check, 'this' is autocast to a non-null type, 
  4.     // so the toString() below resolves to the member function of 
  5.     // the Any class
  6.     return toString()
  7. }

扩展属性

与函数类似，Kotlin 支持扩展属性：

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

注意，因为扩展并没有在类中插入成员，所有并没有一个高效的方式让一个扩展属性拥有幕后字段。这也是为什么扩展属性没有初始化器。它们的行为只能通过显示地提供 getter/setter 来定义。

例子：

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

伴生对象扩展

如果一个类有伴生对象，那么也可以给这个伴生对象定义扩展函数和扩展属性。

  1. class MyClass {
  2.     companion object { } // will be called "Companion"
  3. }
  5. fun MyClass.Companion.foo() {
  6.     // ...
  7. }

就像伴生对象的常规成员，它们也可以利用类名作为限定符来调用。

  1. MyClass.foo()

扩展的域

很多时候，我们在最顶层定义扩展，也就是说，直接位于包的定义之下：

  1. package foo.bar
  3. fun Baz.goo() { ... }

如果要在扩展所在的包之外使用它，我们首先需要在调用侧导入：

  1. package com.example.usage
  3. import foo.bar.goo  // importing all extensions by name "goo"
  5.                     // or
  6. import foo.bar.*    // importing everthing from "foo.bar"
  8. fun usage(baz: Baz) {
  9.     baz.goo()
  10. }

把扩展声明为成员

在一个类内部可以声明其他类的扩展。这样的扩展内部会有多个隐式接收器（implicit receivers）—— 无需限定符就可以访问它们的对象成员。扩展声明所在的类的实例称为分发接收者（dispatch receiver），扩展方法接收器类型的实例称为扩展接收者（extension receiver）。

  1. class D {
  2.     fun bar() { /* ... */ }
  3. }
  5. class C {
  6.     fun baz() { /* ... */ }
  8.     fun D.foo() {
  9.         bar()   // calls D.bar
  10.         baz()   // calls C.baz
  11.     }
  13.     fun caller(d: D) {
  14.         d.foo() // call the extension function
  15.     }
  16. }

当分发接收者（dispatch receiver）和扩展接收者（extension receiver）的成员名字有冲突时，扩展接收着（extension receiver）的优先级更高。可以利用限定 this 语法来引用分发接收者的成员。

  1. class C {
  2.     fun D.foo() {
  3.         toString()          // calls D.toString()
  4.         this@C.toString()   // calls C.toString()
  5.     }
  6. }

声明为成员的扩展可以 是 open，子类可以覆写。这就意味着，这种扩展函数对应于分发接收者（dispatch receiver）是虚函数，但是对于扩展接收者来说，它是静态的。

  1. open class D {
  2. }
  4. class D1 : D() {
  5. }
  7. open class C {
  8.     open fun D.foo() {
  9.         println("D.foo in C")
  10.     }
  12.     open fun D1.foo() {
  13.         println("D1.foo in C")
  14.     }
  16.     fun caller(d: D) {
  17.         d.foo()     // call the extension function
  18.     }
  19. }
  21. class C1 : C() {
  22.     override fun D.foo() {
  23.         println("D.foo in C1")
  24.     }
  26.     override fun D1.foo() {
  27.         println("D1.foo in C1")
  28.     }
  29. }
  31. C().caller(D())     // prints "D.foo in C"
  32. C1().caller(D())    // prints "D.foo in C1" - dispatch receiver is resolved virtually
  33. C().caller(D1())    // prints "D.foo in C" - extension receiver is resolved statically

动力

Java 的世界中，我们习惯了以 “*Utils” 来命名工具类：FileUtils、StringUtils 等等。java.util.Collections 是一个典型，代码很容易变成下面的样子，让人不爽：

  1. // Java
  2. Collections.swap(list, Collections.binarySearch(list,
  3. Collections.max(otherList)), Collections.max(list));

可以使用 static import 来简化一下：

  1. // Java
  2. swap(list, binarySearch(list, max(otherList)), max(list));

稍微好一些，但是我们几乎无法使用 IDE 强大的代码自动补全功能。如果改成如下形式可能会更好：

  1. // Java
  2. list.swap(list.binarySearch(otherList.max()), list.max());

但是我们并不想在 List 类中实现所有可能的方法，不是吗？这就是扩展能够发挥作用的地方。