函數(shù)

函數(shù)聲明

Kotlin 中的函數(shù)使用 fun{: .keyword } 關(guān)鍵字聲明

fun double(x: Int): Int {
}

函數(shù)用法

調(diào)用函數(shù)使用傳統(tǒng)的方法

val result = double(2)

調(diào)用成員函數(shù)使用點表示法

Sample().foo() // 創(chuàng)建類 Sample 實例并調(diào)用 foo

中綴表示法

函數(shù)還可以用中綴表示法調(diào)用，當(dāng)

• 他們是成員函數(shù)或擴展函數(shù)
• 他們只有一個參數(shù)
• 他們用 infix 關(guān)鍵字標(biāo)注

// 給 Int 定義擴展
infix fun Int.shl(x: Int): Int {
……
}

// 用中綴表示法調(diào)用擴展函數(shù)

1 shl 2

// 等同于這樣

1.shl(2)

參數(shù)

函數(shù)參數(shù)使用 Pascal 表示法定義，即 name: type。參數(shù)用逗號隔開。每個參數(shù)必須有顯式類型。

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

默認參數(shù)

函數(shù)參數(shù)可以有默認值，當(dāng)省略相應(yīng)的參數(shù)時使用默認值。與其他語言相比，這可以減少
重載數(shù)量。

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

默認值通過類型后面的 = 及給出的值來定義。

覆蓋方法總是使用與基類型方法相同的默認參數(shù)值。
當(dāng)覆蓋一個帶有默認參數(shù)值的方法時，必須從簽名中省略默認參數(shù)值：

open class A {
    open fun foo(i: Int = 10) { …… }
}

class B : A() {
    override fun foo(i: Int) { …… }  // 不能有默認值
}

命名參數(shù)

可以在調(diào)用函數(shù)時使用命名的函數(shù)參數(shù)。當(dāng)一個函數(shù)有大量的參數(shù)或默認參數(shù)時這會非常方便。

給定以下函數(shù)

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

我們可以使用默認參數(shù)來調(diào)用它

reformat(str)

然而，當(dāng)使用非默認參數(shù)調(diào)用它時，該調(diào)用看起來就像

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

使用命名參數(shù)我們可以使代碼更具有可讀性

reformat(str,
    normalizeCase = true,
    upperCaseFirstLetter = true,
    divideByCamelHumps = false,
    wordSeparator = '_'
)

并且如果我們不需要所有的參數(shù)

reformat(str, wordSeparator = '_')

請注意，在調(diào)用 Java 函數(shù)時不能使用命名參數(shù)語法，因為 Java 字節(jié)碼并不
總是保留函數(shù)參數(shù)的名稱。

返回 Unit 的函數(shù)

如果一個函數(shù)不返回任何有用的值，它的返回類型是 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?) {
    ……
}

單表達式函數(shù)

當(dāng)函數(shù)返回單個表達式時，可以省略花括號并且在 = 符號之后指定代碼體即可

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

當(dāng)返回值類型可由編譯器推斷時，顯式聲明返回類型是可選的

fun double(x: Int) = x * 2

顯式返回類型

具有塊代碼體的函數(shù)必須始終顯式指定返回類型，除非他們旨在返回 Unit，在這種情況下它是可選的。
Kotlin 不推斷具有塊代碼體的函數(shù)的返回類型，因為這樣的函數(shù)在代碼體中可能有復(fù)雜的控制流，并且返回
類型對于讀者(有時甚至對于編譯器)是不明顯的。

可變數(shù)量的參數(shù)(Varargs)

函數(shù)的參數(shù)(通常是最后一個)可以用 vararg 修飾符標(biāo)記：

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
}

允許將可變數(shù)量的參數(shù)傳遞給函數(shù)：

val list = asList(1, 2, 3)

在函數(shù)內(nèi)部，類型 T 的 vararg 參數(shù)的可見方式是作為 T 數(shù)組，即上例中的 ts 變量具有類型 Array <out T>。

只有一個參數(shù)可以標(biāo)注為 vararg。如果 vararg 參數(shù)不是列表中的最后一個參數(shù)， 可以使用
命名參數(shù)語法傳遞其后的參數(shù)的值，或者，如果參數(shù)具有函數(shù)類型，則通過在括號外部
傳一個 lambda。

當(dāng)我們調(diào)用 vararg-函數(shù)時，我們可以一個接一個地傳參，例如 asList(1, 2, 3)，或者，如果我們已經(jīng)有一個數(shù)組
并希望將其內(nèi)容傳給該函數(shù)，我們使用伸展(spread)操作符(在數(shù)組前面加 *)：

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

函數(shù)作用域

在 Kotlin 中函數(shù)可以在文件頂層聲明，這意味著你不需要像一些語言如 Java、C# 或 Scala 那樣創(chuàng)建一個類來保存一個函數(shù)。此外
除了頂層函數(shù)，Kotlin 中函數(shù)也可以聲明在局部作用域、作為成員函數(shù)以及擴展函數(shù)。

局部函數(shù)

Kotlin 支持局部函數(shù)，即一個函數(shù)在另一個函數(shù)內(nèi)部

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

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

局部函數(shù)可以訪問外部函數(shù)(即閉包)的局部變量，所以在上例中，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])
}

成員函數(shù)

成員函數(shù)是在類或?qū)ο髢?nèi)部定義的函數(shù)

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

成員函數(shù)以點表示法調(diào)用

Sample().foo() // 創(chuàng)建類 Sample 實例并調(diào)用 foo

關(guān)于類和覆蓋成員的更多信息參見類和繼承

泛型函數(shù)

函數(shù)可以有泛型參數(shù)，通過在函數(shù)名前使用尖括號指定。

fun <T> singletonList(item: T): List<T> {
    // ……
}

關(guān)于泛型函數(shù)的更多信息參見泛型

內(nèi)聯(lián)函數(shù)

內(nèi)聯(lián)函數(shù)在這里講述

擴展函數(shù)

擴展函數(shù)在其自有章節(jié)講述

高階函數(shù)和 Lambda 表達式

高階函數(shù)和 Lambda 表達式在其自有章節(jié)講述

尾遞歸函數(shù)

Kotlin 支持一種稱為尾遞歸的函數(shù)式編程風(fēng)格。
這允許一些通常用循環(huán)寫的算法改用遞歸函數(shù)來寫，而無堆棧溢出的風(fēng)險。
當(dāng)一個函數(shù)用 tailrec 修飾符標(biāo)記并滿足所需的形式時，編譯器會優(yōu)化該遞歸，留下一個快速而高效的基于循環(huán)的版本。

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

這段代碼計算余弦的不動點(fixpoint of cosine)，這是一個數(shù)學(xué)常數(shù)。 它只是重復(fù)地從 1.0 開始調(diào)用 Math.cos，直到結(jié)果不再改變，產(chǎn)生0.7390851332151607的結(jié)果。最終代碼相當(dāng)于這種更傳統(tǒng)風(fēng)格的代碼：

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

要符合 tailrec 修飾符的條件的話，函數(shù)必須將其自身調(diào)用作為它執(zhí)行的最后一個操作。在遞歸調(diào)用后有更多代碼時，不能使用尾遞歸，并且不能用在 try/catch/finally 塊中。目前尾部遞歸只在 JVM 后端中支持。