kotlin 学习笔记之 函数的使用(一)

函数

函数声明

Kotlin 中的函数使用 fun 关键字声明：

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

函数用法

调用函数使用传统的方法：

val result = double(2)

调用成员函数使用点表示法：

Stream().read() // 创建类 Stream 实例并调用 read()

参数

函数参数使用 Pascal 表示法定义，即 name: type。参数用逗号隔开。 每个参数必须有显式类型：

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

在声明函数参数时，可以在后面使用逗号:

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

默认参数

函数参数可以有默认值，当省略相应的参数时使用默认值。与其他语言相比，这可以减少重载数量：

fun read( b: Array<Byte>, 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

如果在默认参数之后的最后一个参数是 lambda 表达式，那么它既可以作为具名参数在括号内传入，也可以在括号外传入：

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

具名参数

在调用函数时，可以命名它的一个或多个参数。当一个函数有大量的参数，并且很难将一个值与一个参数相关联时，特别是当它是一个布尔值或空值时，这可能会很有帮助。 当您在函数调用中使用命名参数时，您可以自由地更改列出它们的顺序，如果您想使用它们的默认值，您可以完全不使用它们。 考虑以下函数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 = '_')

您可以通过扩展操作符传递数量可变的参数(vararg):

fun foo(vararg strings: String) { /*……*/ } foo(strings = *arrayOf("a", "b", "c"))

对于 JVM 平台：在调用 Java 函数时不能使用具名参数语法，因为 Java 字节码并不总是保留函数参数的名称。

返回 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?) { …… }

单表达式函数

当函数返回单个表达式时，可以省略花括号并且在 = 符号之后指定代码体即可：

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

当返回值类型可由编译器推断时，显式声明返回类型是可选的：

fun double(x: Int) = x * 2

显式返回类型

具有块代码体的函数必须始终显式指定返回类型，除非他们旨在返回 Unit，在这种情况下它是可选的。 Kotlin 不推断具有块代码体的函数的返回类型，因为这样的函数在代码体中可能有复杂的控制流，并且返回类型对于读者（有时甚至对于编译器）是不明显的。

可变数量的参数（Varargs）

函数的参数（通常是最后一个）可以用 vararg 修饰符标记：

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

允许将可变数量的参数传递给函数：

val list = asList(1, 2, 3)

在函数内部，类型 T 的 vararg 参数的可见方式是作为 T 数组，即上例中的 ts 变量具有类型 Array 。

只有一个参数可以标注为 vararg。如果 vararg 参数不是列表中的最后一个参数， 可以使用具名参数语法传递其后的参数的值，或者，如果参数具有函数类型，则通过在括号外部传一个 lambda。

当我们调用 vararg-函数时，我们可以一个接一个地传参，例如 asList(1, 2, 3)，或者，如果我们已经有一个数组并希望将其内容传给该函数，我们使用伸展（spread）操作符（在数组前面加 *）：

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

中缀表示法

标有 infix 关键字的函数也可以使用中缀表示法（忽略该调用的点与圆括号）调用。中缀函数必须满足以下要求：

它们必须是成员函数或扩展函数；它们必须只有一个参数；其参数不得接受可变数量的参数且不能有默认值。 infix fun Int.shl(x: Int): Int { …… } // 用中缀表示法调用该函数 1 shl 2 // 等同于这样 1.shl(2)

中缀函数调用的优先级低于算术操作符、类型转换以及 rangeTo 操作符。 以下表达式是等价的： 1 shl 2 + 3 等价于 1 shl (2 + 3) 0 until n * 2 等价于 0 until (n * 2) xs union ys as Set<> 等价于 xs union (ys as Set<>) 另一方面，中缀函数调用的优先级高于布尔操作符 && 与 ||、is- 与 in- 检测以及其他一些操作符。这些表达式也是等价的： a && b xor c 等价于 a && (b xor c) a xor b in c 等价于 (a xor b) in c 完整的优先级层次结构请参见其语法参考。

请注意，中缀函数总是要求指定接收者与参数。当使用中缀表示法在当前接收者上调用方法时，需要显式使用 this；不能像常规方法调用那样省略。这是确保非模糊解析所必需的。

class MyStringCollection { infix fun add(s: String) { /*……*/ } fun build() { this add "abc" // 正确 add("abc") // 正确 //add "abc" // 错误：必须指定接收者 } }

函数作用域

在 Kotlin 中函数可以在文件顶层声明，这意味着你不需要像一些语言如 Java、C# 或 Scala 那样需要创建一个类来保存一个函数。此外除了顶层函数，Kotlin 中函数也可以声明在局部作用域、作为成员函数以及扩展函数。

局部函数

Kotlin 支持局部函数，即一个函数在另一个函数内部：

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

关于类和覆盖成员的更多信息参见类和继承。