函数

基础函数

函数（function）（也称为方法）在Kotlin中是一等公民。

函数通过fun关键字引入，包含名称、参数列表、返回类型和函数体。

/**
 * 普通函数
 */
fun function1(name: String, age: Int): String {
    return "Hello I'm $name, I was $age years old."
}

class Person {
    /**
     * 成员函数
     */
    fun function2(name: String, age: Int): String {
        return "Hello I'm $name, I was $age years old."
    }

    /**
     * 类函数，companion object相当于static关键字的作用
     */
    companion object {
        fun function3(name: String, age: Int): String {
            return "Hello I'm $name, I was $age years old."
        }
    }
}

/**
 * 工具类
 * 其中定义的所有方法都是静态方法
 */
object Utils {
    /**
     * 类函数
     */
    fun function4(): String {
        return "Hello I'm luofeng"
    }
}

/**
 * 单表达式函数：当酣睡返回单个表达式时，可以省略花括号（{}），并且在等号（=）之后直接指定代码体
 */
fun function5(name: String): String = "Hello I'm $name"

/**
 * 默认参数
 */
fun function6(name: String, age: Int = 22): String {
    return "Hello I'm $name, I was $age years old."
}

/**
 * 可变参数
 */
fun function7(vararg names: String): String {
    return names.joinToString(", ")
}

fun main() {
    println("result -> " + function1("lixingyun", 19))
    println("result -> " + Person().function2("wanglin", 20))
    println("result -> " + Person.function3("xiaoyan", 21))
    println("result -> " + Utils.function4())
    println("result -> " + function5("shihao"))
    println("result -> " + function6("qinyu"))
    println("result -> " + function7("lindong", "limuwan", "liushen"))

    /**
     * 局部方法
     */
    fun function8(name: String): String {
        val age = (19..25).random()
        return "Hello I'm $name, I was $age years old."
    }
    println("result -> " + function8("yunxi"))
}

高阶函数

所谓高阶函数，就是将function作为参数或返回值的函数。

/**
 * 高阶函数：将函数作为参数
 */
fun sum1(arrs: Array<Int>, callback: (Int) -> Unit): Int {
    var result = 0
    for (i in arrs) {
        result += i
        callback(result)
    }
    return result
}

/**
 * 高阶函数：将函数作为返回值
 */
fun sum2(arrs: Array<Int>): (value: Int) -> Float {
    return fun(value: Int): Float {
        var result = 0
        for (i in arrs) {
            result += i * value
        }
        return result.toFloat()
    }
}

fun main() {
    val arrs = arrayOf(1, 2, 3, 4, 5)
    sum1(arrs) {
        println("sum1: $it")
    }
    val sum2 = sum2(arrs)
    println("sum2: ${sum2(2)}")
}

Lambda表达式

Lambda表达式在很多语言中都存在，它是一种语法糖，可以很有效地精简代码量。

Kotlin中的Lambda表达式的语法如下。

// 无参数
val/var 变量名 = 操作代码
// 或者
val/var 变量名 = { 操作代码 }

// 有参数
// 书写方式一（如果只有一行操作代码，{}可以省掉）
val/var 变量名 = { 参数1: 参数类型, 参数2: 参数类型, ...... -> { 操作代码 } }
// 书写方式二（如果只有一行操作代码，{}可以省掉）
val/var 变量名: (参数类型1, 参数类型2, ......) -> 返回值类型/Unit = { 参数1, 参数2, ...... -> { 操作代码 } }

对于Java工程师而言，明显更习惯于第一种书写方式。

/**
 * 无参数的Lambda表达式
 */
val lambda1 = println("lixingyun")
val lambda2 = { println("wanglin") }

/**
 * 有参数的Lambda表达式
 */
val lambda3 = { name: String -> println(name) }
// 另一种定义方式
val lambda4: (String) -> String = { name -> "Hello I'm $name." }
// 多参数
val lambda5 = { name: String, age: Int -> { "Hello I'm $name, I was $age years old." } }
// 另一种定义方式
val lambda6: (String, Int) -> String = { name, age -> "Hello I'm $name, I was $age years old." }

/**
 * 当只有一个参数时，可以使用Kotlin语言约定的隐式参数it
 */
val arrs = arrayOf(1, 2, 3, 4, 5)
val lambda7 = arrs.filter { it % 2 == 1 }

/**
 * 当使用lambda表达式时，可以用下划线（_）表示不处理未使用的参数
 */
val lambda8 = { _: Int, name: String -> println(name) }

fun main() {
    lambda1
    // 带{}的调用时需要加上()
    lambda2()

    lambda3("xiaoyan")
    println(lambda4("luofeng"))
    println(lambda5("shihao", 18)())
    println(lambda6("qinyu", 19))
    println(lambda7)
    lambda8(1, "lindong")
}

匿名函数

/**
 * 匿名函数
 */
val anonymous = fun (x: Int, y: Int): Int = x + y

fun main() {
    println(anonymous(1, 2))
}

闭包

闭包（Closure）的概念在很多语言中都有，包括Python、Go、Scala、Groovy、JavaScript等。

所谓闭包（Closure），其实就是内层函数能够访问外层函数的变量，它起到了将内外部函数连接起来的作用。

/**
 * 闭包：内外部变量相加
 */
fun closure(arg1: Int): (arg2: Int, (Int) -> Unit) -> Unit {
    return fun(arg2: Int, accumulator: (Int) -> Unit) {
        accumulator(arg1 + arg2)
    }
}

fun main() {
    closure(1)(2) {
        println("result: $it")
    }
}

函数字面值

fun main() {
    // 变量temp的字面值就是(Int, Int) -> Int
    var expValue: ((Int, Int) -> Int)? = null

    /**
     * 函数字面值
     */
    fun test() {
        // 可以这样赋值，fun (x: Int, y: Int)...就是函数字面值
        expValue = fun (x: Int, y: Int): Int {
            return x + y
        }
        println(expValue!!(1, 2))

        // 或者这样赋值，{ x, y -> x + y }就是函数字面值
        expValue = { x, y -> x + y }
        println(expValue(3, 4))
    }
    // 运行函数
    test()
}

解构声明

Kotlin的解构声明（Destructuring Declarations）类似于Python中的元组拆包（Tuple Packing）功能。

/**
 * 解构声明
 */
data class Person(val name: String, val age: Int)

fun main() {
    val person = Person("lixingyun", 20)
    val (name, age) = Person("lixingyun", 20)
    println(person)
    println("name: $name, age: $age")
    // 都是true
    println(person.name == name)
    println(person.age == age)
    println(person.name === name)
    println(person.age === age)
}

---

感谢支持

更多内容，请移步《超级个体》。