【Kotlin精简】第4章 函数

1 简介

函数是用来运行代码的载体，可以在一个函数里编写很多行代码，当运行这个函数时，函数中的所有代码会全部运行。
Kotlin中的函数同Java完全面向对象的规则不太一样，在Kotlin的世界里，函数也是准C位的，同面向对象一样属于一等公民，Kotlin也提倡函数式编程。
Kotlin中的函数分为普通函数，中缀函数，局部函数，泛型函数，尾递归函数，扩展函数，内联函数，高阶函数，lambada函数等

2 普通函数

使用fun关键字创建一个函数。

class Func {

    fun main(){

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

        // 2.调用五返回值函数，Unit可省略不写
        logString(100)

        // 3.调用普通函数，有返回值
        val num = double(10)

        // 4.调用普通单表达式函数，有返回值
        val num2 = double2(10)

        // 5.调用普通函数，参数有默认值的情况
        // 除了str以外其余的参数名都含有默认值，我们可以使用默认调用。
        // 或者指定要具体参数名调用，没指定的情况使用默认参数值
        val str = "NO.1"
        reformat(str,
            normalizeCase = true,
            wordSeparator = '_'
        )

        // 6.调用可变参数的函数，使用vararg修饰参数
        // 当我们已经有一个数组类型的参数的时候，
        // 我们可以用扩展符（*）来作为参数传入
        val arr = arrayOf(1,2,3)
        val list = asList(*arr, 4,5) // list: 1,2,3,4,5

        // 7.继承重写的函数，不能有默认值
        class B : A() {
            override fun foo(i: Int) { }
        }

    }

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

    private fun double2(x: Int): Int = x * 2 // 可简写：fun double(x: Int) = x * 2

    // 没有返回值类似Java的void，Unit可以不写
    private fun logString(x:Int):Unit{ Log.i("NormalFunc", x.toString()) }  //等同于 fun test(x:Int){ print(x) }

    // 默认参数函数
    private fun reformat(str: String,
                         normalizeCase: Boolean = true,
                         upperCaseFirstLetter: Boolean = true,
                         wordSeparator: Char = ' ') {
    }

    // 这里的T代表泛型，总是泛型总是出现在函数名的前面
    private 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
    }
}

// 实际上会编译成类中的静态方法
fun outFunc(){

}

open class A {
    open fun foo(i: Int = 10) { }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

fun（function的简写）是定义函数的关键字，无论定义什么函数，都一定要使用fun来声明。

3 中缀函数

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

1. 它们必须是成员函数或扩展函数。
2. 它们必须只有一个参数。
3. 其参数不得接受可变数量的参数且不能有默认值。

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

// 用中缀表示法调用该函数
1 shl 2

// 等同于这样
1.shl(2)
1
2
3
4
5
6
7

中缀函数调用的优先级低于算术操作符、型转换以及 rangeTo 操作符。

1 shl 2 + 3 等价于 1 shl (2 + 3)
另一方面，中缀函数调用的优先级高于布尔操作符 && 与 ||、is- 与in-检测以及其他一些操作符。
a && b xor c 等价于 a && (b xor c)
a xor b in c 等价于 (a xor b) in c

4 局部函数

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())
}
1
2
3
4
5
6
7
8
9

局部函数可以访问外部函数（闭包）的局部变量。在上例中，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])
}

1
2
3
4
5
6
7
8
9
10
11

5 泛型函数

和其他语言一样，Kotlin是可以使用泛型

5.1 泛型

class Box<T>(t: T) {
    var value = t
}
1
2
3

我们在Java中使用泛型的时候，考虑一下情况

// Java
interface Collection<E> …… {
  void addAll(Collection<E> items);
}
// Java
void copyAll(Collection<Object> to, Collection<String> from) {
  to.addAll(from);
  // ！！！对于这种简单声明的 addAll 将不能编译：
  // Collection 不是 Collection