函数

函数声明

在 kotlin 中用关键字 fun 声明函数:

  1. fun double(x: Int): Int {
  2. }

函数用法

通过传统的方法调用函数

  1. val result = double(2)

通过.调用成员函数

  1. Sample().foo() // 创建Sample类的实例,调用foo方法

中缀符号

在满足以下条件时,函数也可以通过中缀符号进行调用:

 它们是成员函数或者是扩展函数
 只有一个参数
使用infix关键词进行标记

  1. //给 Int 定义一个扩展方法
  2. infix fun Int.shl(x: Int): Int {
  3. ...
  4. }
  5. 1 shl 2 //用中缀注解调用扩展函数
  6. 1.shl(2)

参数

函数参数是用 Pascal 符号定义的 name:type。参数之间用逗号隔开,每个参数必须指明类型。

  1. fun powerOf(number: Int, exponent: Int) {
  2. ...
  3. }

默认参数

函数参数可以设置默认值,当参数被忽略时会使用默认值。这样相比其他语言可以减少重载。

  1. fun read(b: Array<Byte>, off: Int = 0, len: Int = b.size ) {
  2. ...
  3. }

默认值可以通过在type类型后使用=号进行赋值

命名参数

在调用函数时可以参数可以命名。这对于那种有大量参数的函数是很方便的.

下面是一个例子:

  1. fun reformat(str: String, normalizeCase: Boolean = true,upperCaseFirstLetter: Boolean = true,
  2. divideByCamelHumps: Boolean = false,
  3. wordSeparator: Char = ' ') {
  4. ...
  5. }

我们可以使用默认参数

reformat(str)

然而当调用非默认参数是就需要像下面这样:

  1. reformat(str, true, true, false, '_')

使用命名参数我们可以让代码可读性更强:

  1. reformat(str,
  2. normalizeCase = true,
  3. uppercaseFirstLetter = true,
  4. divideByCamelHumps = false,
  5. wordSeparator = '_'
  6. )

如果不需要全部参数的话可以这样:

  1. reformat(str, wordSeparator = '_')

注意,命名参数语法不能够被用于调用Java函数中,因为Java的字节码不能确保方法参数命名的不变性

不带返回值的参数

如果函数不会返回任何有用值,那么他的返回类型就是 Unit .Unit 是一个只有唯一值Unit的类型.这个值并不需要被直接返回:

  1. fun printHello(name: String?): Unit {
  2. if (name != null)
  3. println("Hello ${name}")
  4. else
  5. println("Hi there!")
  6. // `return Unit` or `return` is optional
  7. }

Unit 返回值也可以省略,比如下面这样:

  1. fun printHello(name: String?) {
  2. ...
  3. }

单表达式函数

当函数只返回单个表达式时,大括号可以省略并在 = 后面定义函数体

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

在编译器可以推断出返回值类型的时候,返回值的类型可以省略:

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

明确返回类型

下面的例子中必须有明确返回类型,除非他是返回 Unit类型的值,Kotlin 并不会对函数体重的返回类型进行推断,因为函数体中可能有复杂的控制流,他的返回类型未必对读者可见(甚至对编译器而言也有可能是不可见的):

变长参数

函数的参数(通常是最后一个参数)可以用 vararg 修饰符进行标记:

  1. fun <T> asList(vararg ts: T): List<T> {
  2. val result = ArrayList<T>()
  3. for (t in ts)
  4. result.add(t)
  5. return result
  6. }

标记后,允许给函数传递可变长度的参数:

  1. val list = asList(1, 2, 3)

只有一个参数可以被标注为 vararg 。加入vararg并不是列表中的最后一个参数,那么后面的参数需要通过命名参数语法进行传值,再或者如果这个参数是函数类型,就需要通过lambda法则.

当调用变长参数的函数时,我们可以一个一个的传递参数,比如 asList(1, 2, 3),或者我们要传递一个 array 的内容给函数,我们就可以使用 * 前缀操作符:

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

函数范围

Kotlin 中可以在文件顶级声明函数,这就意味者你不用像在Java,C#或是Scala一样创建一个类来持有函数。除了顶级函数,Kotlin 函数可以声明为局部的,作为成员函数或扩展函数。

局部函数

Kotlin 支持局部函数,比如在一个函数包含另一函数。

  1. fun dfs(graph: Graph) {
  2. fun dfs(current: Vertex, visited: Set<Vertex>) {
  3. if (!visited.add(current)) return
  4. for (v in current.neighbors)
  5. dfs(v, visited)
  6. }
  7. dfs(graph.vertices[0], HashSet())
  8. }

局部函数可以访问外部函数的局部变量(比如闭包)

  1. fun dfs(graph: Graph) {
  2. val visited = HashSet<Vertex>()
  3. fun dfs(current: Vertex) {
  4. if (!visited.add(current)) return
  5. for (v in current.neighbors)
  6. dfs(v)
  7. }
  8. dfs(graph.vertices[0])
  9. }

局部函数甚至可以返回到外部函数 qualified return expressions

  1. fun reachable(from: Vertex, to: Vertex): Boolean {
  2. val visited = HashSet<Vertex>()
  3. fun dfs(current: Vertex) {
  4. if (current == to) return@reachable true
  5. if (!visited.add(current)) return
  6. for (v in current.neighbors)
  7. dfs(v)
  8. }
  9. dfs(from)
  10. return false
  11. }

成员函数

成员函数是定义在一个类或对象里边的

  1. class Sample() {
  2. fun foo() { print("Foo") }
  3. }

成员函数可以用 . 的方式调用

  1. Sample.foo()

更多请参看继承

泛型函数

函数可以有泛型参数,样式是在函数名前加上尖括号。

  1. fun <T> sigletonArray(item: T): Array<T> {
  2. return Array<T>(1, {item})
  3. }

更多请参看泛型

内联函数

参看这里

扩展函数

参看这里

高阶函数和 lambda 表达式

参看这里

尾递归函数

Kotlin 支持函数式编程的尾递归。这个允许一些算法可以通过循环而不是递归解决问题,从而避免了栈溢出。当函数被标记为 tailrec 时,编译器会优化递归,并用高效迅速的循环代替它。

  1. tailrec fun findFixPoint(x: Double = 1.0): Double
  2. = if (x == Math.cos(x)) x else findFixPoint(Math.cos(x))

这段代码计算的是数学上的余弦不动点。Math.cos 从 1.0 开始不断重复,直到值不变为止,结果是 0.7390851332151607
这段代码和下面的是等效的:

  1. private fun findFixPoint(): Double {
  2. var x = 1.0
  3. while (true) {
  4. val y = Math.cos(x)
  5. if ( x == y ) return y
  6. x = y
  7. }
  8. }

使用 tailrec 修饰符必须在最后一个操作中调用自己。在递归调用代码后面是不允许有其它代码的,并且也不可以在 try/catch/finall 块中进行使用。当前的尾递归只在 JVM 的后端中可以用