Kotlin 变量与函数

1、变量

// 变量声明的格式
// 关键字  变量名称  变量类型
    var     name    : String  // 声明了一个String类型的name变量

// 关键字
// var     可读，可写
// val     只读，不可变

// 变量赋值
// 方式1：声明的同时赋值
val a:Int = 0  // 显式声明变量类型
var a = 0      // 编译器根据所赋的值自动推断变量类型
// 方式2：声明和赋值分开
var b:Int      // 先声明
b = 0          // 再赋值

//只声明不约束具体类型会报错
var c

2、函数

// 函数声明的格式
/*
修饰符 函数名(参数名:参数类型, 参数名:参数类型, ...) : 返回值类型 {
    ...
    方法体
    ...
    return 返回值;
}

// 修饰符： private 私有，public 公有（省略时默认为 public）
*/

public fun sum(x: Int, y: Int): Int {
    return x + y
}

 3、函数默认参数

通过在类型的后面添加 = 符号来设置参数的默认值

// 函数参数可以有默认值
fun read(
    b: Char,
    off: Int = 0,
    len: Int = b.size,
) { /*……*/ }
// 当省略相应的参数时使用默认值
read('C')
// 具名参数方式调用
read(b='C', off=1)

// 一个有默认值参数在一个无默认值的参数之前
fun foo(
    bar: Int = 0,
    baz: Int,
) { /*……*/ }
// 此时必须使用具名参数方式调用
foo(baz = 1) // 使用默认值 bar = 0

 4、函数参数是lamba表达式

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

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

foo(1) { println("hello") }     // 使用默认值 baz = 1, 括号外传入qux
foo(qux = { println("hello") }) // 使用两个默认值 bar = 0 与 baz = 1, 括号内传入qux
foo { println("hello") }        // 使用两个默认值 bar = 0 与 baz = 1, 括号外传入qux

5、函数可变参数

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

fun foo(vararg strings: String) { /*……*/ }
// 可通过具名参数和展开操作符来传入可变参数（strings）
foo(strings = *arrayOf("a", "b", "c"))

6、单表达式函数

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

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

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

fun double(x: Int) = x * 2

7、函数返回类型

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

• 显式返回类型

具有块代码体的函数必须始终显式指定返回类型，除非他们旨在返回 Unit

8、局部函数

函数可以声明在局部作用域，即一个函数在另一个函数内部

// 外部函数
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())
}

局部函数可以访问外部函数（闭包）的局部变量

fun dfs(graph: Graph) {
    // 闭包局部变量 visited 
    val visited = HashSet<Vertex>()
    fun dfs(current: Vertex) {
        // 局部函数访问 visited 
        if (!visited.add(current)) return
        for (v in current.neighbors)
            dfs(v)
    }

    dfs(graph.vertices[0])
}

9、成员函数

在类或对象内部定义的函数，即成员函数

class Sample {
    //成员函数
    fun foo() { print("Foo") }
}

// 成员函数以点表示法调用
Sample().foo() // 创建类 Sample 实例并调用 foo

10、泛型函数

函数可以有泛型参数，通过在函数名前使用尖括号<>指定

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

11、尾递归函数

用 tailrec 修饰符标记，并满足以下形式条件（编译器会优化该递归， 留下一个快速而高效的基于循环的版本）

• 函数必须将其自身调用作为它执行的最后一个操作
• 在递归调用后有更多代码时
  • 不能使用尾递归
  • 不能用在 try/catch/finally 块中
  • 不能用于 open 的函数

val eps = 1E-10
// 尾递归函数
tailrec fun findFixPoint(x: Double = 1.0): Double =
    if (Math.abs(x - Math.cos(x)) < eps) x else findFixPoint(Math.cos(x))

// 最终代码相当于这种更传统风格的代码
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)
    }
}

12、中缀函数

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"        // 错误：必须指定接收者
    }
}