函数

Kotlin 中的函数使用 fun 关键字定义:

fun double(x: Int): Int {
    return 2 * x
}

函数使用

val result = double(2)

Stream().read() // 创建一个 Stream 类的实例, 然后调用这个实例的 read() 函数

参数

fun powerOf(number: Int, exponent: Int): Int { /*...*/ }

fun powerOf(
    number: Int,
    exponent: Int, // 尾随逗号(trailing comma)
) { /*...*/ }

默认参数

fun read(
    b: ByteArray,
    off: Int = 0,
    len: Int = b.size,
) { /*...*/ }

参数默认值的定义方法是, 在参数类型之后, 添加 = 和默认值.

open class A {
    open fun foo(i: Int = 10) { /*...*/ }
}

class B : A() {
    override fun foo(i: Int) { /*...*/ }  // 这里不允许指定默认参数值.
}

fun foo(
    bar: Int = 0,
    baz: Int,
) { /*...*/ }

foo(baz = 1) // 这里将会使用默认参数 bar = 0

fun foo(
    bar: Int = 0,
    baz: Int = 1,
    qux: () -> Unit,
) { /*...*/ }

foo(1) { println("hello") }     // 这里将会使用默认参数 baz = 1
foo(qux = { println("hello") }) // 这里将会使用默认参数 bar = 0 和 baz = 1
foo { println("hello") }        // 这里将会使用默认参数 bar = 0 和 baz = 1

命名参数

调用函数时, 你可以指定一个或多个参数名. 当函数参数很多时, 将实际参数值与函数参数一一对应起来会变得很困难, 尤其是如果参数值是布尔值, 或 null 值, 这种情况下, 指定参数名是一种非常便利的功能.

比如, reformat() 函数有 4 个指定了默认值的参数.

fun reformat(
    str: String,
    normalizeCase: Boolean = true,
    upperCaseFirstLetter: Boolean = true,
    divideByCamelHumps: Boolean = false,
    wordSeparator: Char = ' ',
) { /*...*/ }

reformat(
    "String!",
    false,
    upperCaseFirstLetter = false,
    divideByCamelHumps = true,
    '_'
)

reformat("This is a long String!")

reformat("This is a short String!", upperCaseFirstLetter = false, wordSeparator = '_')

还可以通过 展开(spread) 操作符, 以命名参数的方式传递不定数量参数 (vararg):

fun foo(vararg strings: String) { /*...*/ }

foo(strings = *arrayOf("a", "b", "c"))

返回值为 Unit 的函数

如果一个函数不返回有意义的结果值, 那么它的返回类型为 Unit. Unit 类型只有唯一的一个值 - Unit. 在函数中, 不需要明确地返回这个值:

fun printHello(name: String?): Unit {
    if (name != null)
        println("Hello $name")
    else
        println("Hi there!")
    // 这里可以写 `return Unit` 或者 `return`, 都是可选的
}

返回类型 Unit 的声明本身也是可选的. 上例中的代码等价于:

fun printHello(name: String?) { ... }

单表达式函数(Single-expression function)

如果函数体只包含单个表达式, 那么大括号可以省略, 函数体可以直接写在 = 之后:

fun double(x: Int): Int = x * 2

fun double(x: Int) = x * 2

不定数量参数(varargs)

你可以对一个函数的一个参数 (通常是参数中的最后一个) 标记 vararg 修饰符:

fun <T> asList(vararg ts: T): List<T> {
    val result = ArrayList<T>()
    for (t in ts) // ts 是一个 Array
        result.add(t)
    return result
}

val list = asList(1, 2, 3)

在函数内部, 类型为 T 的 vararg 参数会被看作一个 T 类型的数组, 上例中的 ts 变量的类型为 Array<out T>.

只有一个参数可以标记为 vararg. 如果 vararg 参数不是函数的最后一个参数, 那么对于 vararg 参数之后的其他参数, 可以使用命名参数语法来传递参数值, 或者, 如果参数类型是函数, 可以在括号之外传递一个 Lambda 表达式.

调用一个存在 vararg 参数的函数时, 你可以传递单独的参数值, 比如, asList(1, 2, 3). 如果你已经有了一个数组, 希望将它的内容传递给函数, 你可以使用展开(spread) 操作符(在数组之前加一个 *):

val a = arrayOf(1, 2, 3)
val list = asList(-1, 0, *a, 4)

如果要向 vararg 参数传递一个基本类型的数组, 你需要使用 toTypedArray() 函数, 将它转换为一个通常的(有类型的)数组:

val a = intArrayOf(1, 2, 3) // IntArray 是基本类型的数组
val list = asList(-1, 0, *a.toTypedArray(), 4)

中缀标记法(Infix notation)

使用 infix 关键字标记的函数, 也可以使用中缀标记法(infix notation)来调用(调用时省略点号和括号). 中缀函数需要满足以下条件:

infix fun Int.shl(x: Int): Int { ... }

// 使用中缀标记法调用函数
1 shl 2

// 上面的语句等价于
1.shl(2)

注意, 中缀函数的接受者和参数都需要明确指定. 如果使用中缀标记法调用当前接受者的一个方法, 需要明确指定 this. 这是为了保证语法解析不出现歧义.

class MyStringCollection {
    infix fun add(s: String) { /*...*/ }

    fun build() {
        this add "abc"   // 正确用法
        add("abc")       // 正确用法
        //add "abc"      // 错误用法: 方法的接受者必须明确指定
    }
}

函数的范围

局部函数

fun dfs(graph: Graph) {
    fun dfs(current: Vertex, visited: MutableSet<Vertex>) {
        if (!visited.add(current)) return
        for (v in current.neighbors)
            dfs(v, visited)
    }

    dfs(graph.vertices[0], HashSet())
}

局部函数可以访问外部函数中的局部变量(闭包). 在上面的例子中, visited 可以定义为一个局部变量:

fun dfs(graph: Graph) {
    val visited = HashSet<Vertex>()
    fun dfs(current: Vertex) {
        if (!visited.add(current)) return
        for (v in current.neighbors)
            dfs(v)
    }

    dfs(graph.vertices[0])
}

成员函数

class Sample {
    fun foo() { print("Foo") }
}

Sample().foo() // 创建 Sample 类的实例, 并调用 foo 函数

尾递归函数(Tail recursive function)

Kotlin 支持一种称为尾递归(tail recursion) 的函数式编程方式. 对于某些算法, 本来需要使用循环来实现, 你可以改用递归函数, 但同时不会存在栈溢出(stack overflow)的风险. 当一个函数标记为 tailrec, 并且满足某些形式上的要求, 编译器就会对代码进行优化, 消除函数的递归调用, 产生一段基于循环实现的, 快速而且高效的代码:

val eps = 1E-10 // 这个精度已经"足够"了, 也可以设置为更高精度: 10^-15

tailrec fun findFixPoint(x: Double = 1.0): Double =
    if (Math.abs(x - Math.cos(x)) < eps) x else findFixPoint(Math.cos(x))

上面的代码计算余弦函数的 不动点(fixpoint), 结果应该是一个数学上的常数. 这个函数只是简单地从 1.0 开始不断重复地调用 Math.cos 函数, 直到计算结果不再变化为止, 对于示例中给定的 eps 精度值, 计算结果将是 0.7390851332151611. 编译器优化产生的代码等价于下面这种传统方式编写的代码:

val eps = 1E-10 // 这个精度已经"足够"了, 也可以设置为更高精度: 10^-15

private fun findFixPoint(): Double {
    var x = 1.0
    while (true) {
        val y = Math.cos(x)
        if (Math.abs(x - y) < eps) return x
        x = Math.cos(x)
    }
}

要符合 tailrec 修饰符的要求, 函数必须在它执行的所有操作的最后一步, 递归调用它自身. 如果在这个递归调用之后还存在其他代码, 那么你不能使用尾递归, 也不能用在 try/catch/finally 结构内, 而且不能用于 open 的函数. 目前只有 Kotlin for JVM 和 Kotlin/Native 支持尾递归.

函数﻿

函数使用﻿

参数﻿

默认参数﻿

命名参数﻿

note

返回值为 Unit 的函数﻿

单表达式函数(Single-expression function)﻿

明确指定返回值类型﻿

不定数量参数(varargs)﻿

中缀标记法(Infix notation)﻿

note

函数的范围﻿

局部函数﻿

成员函数﻿

泛型函数﻿

尾递归函数(Tail recursive function)﻿

函数