重学Kotlin（六）函数

哆啦A梦z

已于 2022-12-09 16:57:45 修改

阅读量310

点赞数

分类专栏：重学Kotlin 文章标签： kotlin android 开发语言

于 2022-12-08 18:11:08 首次发布

本文链接：https://blog.csdn.net/zx_android/article/details/128234115

版权

重学Kotlin 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

函数、高阶函数、Lambda、内联函数

函数

普通函数用法

//声明
//b:Int = 10代表默认值
fun double(x: Int,b:Int = 10): Int {
    return 2 * x
}
//普通调用,入参中的22会覆盖函数用的默认值10
val result = double(1,22)
//具名调用,指定入参名称再赋值，不赋值的使用原函数的默认值
val result = double(x = 1)
//

如果函数作为入参

 fun double(x: Int,b:Int = 10,qux: () -> Int): Int {
        //invoke代表执行此函数并返回值100
        val result = qux.invoke()
        return (2 * x)+result
    }
    //调用
   double(x=1, qux = {
            logDebug("函数体")
            100
        })

函数不返回任何有用的值，它的返回类型是 Unit，可省略不写

单表达式函数

当函数返回单个表达式时，可以省略{}换为=

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

可变数量的参数（Varargs）

  fun double(x: Int,b:Int = 10,qux: () -> Int,vararg ints:Int): Int {
        var counts = 0
        for (i in ints){
            counts+=i
        }
        logDebug("counts == $counts")
        //invoke代表执行此函数并返回值100
        val result = qux.invoke()
        return (2 * x)+result
    }
    //调用
       double(x=1, qux = {
                logDebug("函数体")
                100
            }, ints = intArrayOf(1,2,3))

局部函数

Kotlin 支持局部函数，即一个函数在另一个函数内部，局部函数可以访问外部函数（即闭包）的局部变量

    fun af(){
        val age = 10
        fun bf(cc:Int){
            val agec = age+cc
            logDebug("年龄：$agec")
        }
        //调用局部函数
        bf(20)
    }
    //调用：
      af()

泛型函数

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

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

高阶函数与 lambda 表达式

含义：高阶函数是将函数用作参数或返回值的函数

函数类型

函数类型都有一个圆括号括起来的参数类型列表以及一个返回类型：(A, B) -> C 表示接受类型分别为 A 与 B 两个参数并返回一个 C 类型值的函数类型。参数类型列表可以为空，如 () -> A。Unit 返回类型不可省略。
函数类型可以有一个额外的接收者类型，它在表示法中的点之前指定：类型 A.(B) -> C
在这样的函数字面值内部，传给调用的接收者对象成为隐式的 this，以便访问接收者对象的成员而无需任何额外的限定符，亦可使用 this 表达式 访问接收者对象
Kotlin带有接收者的函数类型(block: T.() -＞ Unit)
Kotlin中T.()-＞Unit 、(T) -＞ Unit 、()-＞Unit傻傻分不清

在这里插入图片描述

挂起函数有一个 suspend 修饰符，例如 suspend () -> Unit 或者 suspend A.(B) -> C。

this 表达式

    class A { // 隐式标签 @A
        inner class B { // 隐式标签 @B
            fun Int.foo() { // 隐式标签 @foo
                val a = this@A // A 的 this
                val b = this@B // B 的 this

                val c = this // foo() 的接收者，一个 Int
                val c1 = this@foo // foo() 的接收者，一个 Int

            }
        }
    }

这种行为与扩展函数类似，扩展函数也允许在函数体内部访问接收者对象的成员。

Lambda 表达式语法

val sum: (Int, Int) -> Int = { x: Int, y: Int -> x + y }

lambda 表达式总是括在花括号中， 参数声明放在花括号内，并有可选的类型标注， 函数体跟在一个 -> 符号之后。如果推断出的该 lambda 的返回类型不是 Unit，那么该 lambda 主体中的最后一个（或可能是单个）表达式会视为返回值。

例如调用fold方法：

val items = listOf(1, 2, 3, 4, 5)

    // Lambdas 表达式是花括号括起来的代码块。
    items.fold(0, { 
        // 如果一个 lambda 表达式有参数，前面是参数，后跟“->”
        acc: Int, i: Int -> 
        print("acc = $acc, i = $i, ") 
        val result = acc + i
        println("result = $result")
        // lambda 表达式中的最后一个表达式是返回值：
        result
    })

传递末尾的 lambda 表达式

在 Kotlin 中有一个约定：如果函数的最后一个参数是函数，那么作为入参传入的 lambda 表达式可以放在圆括号之外：

android studio也会警告提示：Lambda argument should be moved out of parentheses （Lambda参数应移出括号）

val product = items.fold(1) { acc, e -> acc * e }

从 lambda 表达式中返回一个值

ints.filter {
    val shouldFilter = it > 0 
    //隐式返回
    shouldFilter
}

ints.filter {
    val shouldFilter = it > 0 
    //显式返回
    return@filter shouldFilter
}

如果 lambda 表达式的参数未使用，那么可以用下划线取代其名称：

map.forEach { _, value -> println("$value!") }

下面我们自定义一个高阶函数实现加减乘除的计算：
（有点在函数中调用传入的参数和函数的意思）

        /* methodName函数名
         * (Int,String) 函数的参数类型
         * Unit 函数返回值 === void
         */
        //methodName : (Int,String) -> Unit
    
        fun calculate(num1: Int, num2: Int, doCalculate: (Int, Int) -> Int): Int {
            //将num1,num2传递给doCalculate作为参数
            return doCalculate(num1, num2)
        }

调用

//lambda隐藏了参数名,btn_invoke显式表示
            btn_invoke.setOnClickListener { btn_invoke->

            }
            val result = calculate(11,22,{n1,n2-> n1+n2})
            val result2 = calculate(11,22) { n1, n2 ->
                n1 + n2
            }
            //不使用的可以省略
            val result3 = calculate(11,22) { n1, _ ->
                n1 + 1
            }
            //是不是特别像如下常写代码：
            rv_list.setOnItemClickListener { holder, position ->

            }
            val result4 = calculate(11,22) {
                    n1, n2 ->
                    val re = n1 + n2
                //最后一行作为返回值
                    re
            }

匿名函数

lambda 表达式语法缺少的一个东西是指定函数的返回类型的能力。在大多数情况下，这是不必要的。因为返回类型可以自动推断出来。然而，如果确实需要显式指定，可以使用另一种语法：匿名函数 。

fun(x: Int, y: Int): Int = x + y

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

ints.filter(fun(item) = item > 0)

Lambda表达式与匿名函数之间的另一个区别是非局部返回的行为。一个不带标签的 return 语句总是在用 fun 关键字声明的函数中返回。这意味着 lambda 表达式中的 return 将从包含它的函数返回，而匿名函数中的 return 将从匿名函数自身返回。

内联函数

内联函数的原理也很简单：Kotlin编译器在编译时把内联函数内代码自动替换到要调用的地方，这样就解决了运行时的内存开销

当一个函数被声明为inline时，它的函数体是内联的——换句话说，函数体会被直接替换到函数调用的地方，而不是被正常调用

说白了就是在调用处插入函数体代码，以此减少新建函数栈和对象的内存开销！被inline修饰的函数或lambda表达式，在调用时都会被内联(在调用处插入函数体代码)。
在这里插入图片描述
步骤一，将Lambda表达式的代码替换到函数类型参数调用的地方
步骤二，将内联函数中全部代码替换到函数调用的地方，替换后即为

val rideNum = a + b

Kotlin——高阶函数

具体化的类型参数

如果你希望把

treeNode.findParentOfType(MyTreeNode::class.java)

改为如下的优雅调用

treeNode.findParentOfType<MyTreeNode>()

那么你需要新增reified 关键字来实例化
在kotlin中一个内联函数（inline）可以被具体化（reified），这意味着我们可以得到使用泛型类型的Class,即调用输入的泛型也可以被拿到实例。

inline fun <reified T> TreeNode.findParentOfType(): T? {
    var p = parent
    while (p != null && p !is T) {
        p = p.parent
    }
    return p as T?
}

我们使用 reified 修饰符来限定类型参数，现在可以在函数内部访问它了，几乎就像是一个普通的类一样。由于函数是内联的，不需要反射，正常的操作符如 !is 和 as 现在都能用了。此外，我们还可以按照上面提到的方式调用它：myTree.findParentOfType()。

虽然在许多情况下可能不需要反射，但我们仍然可以对一个具体化的类型参数使用它：

inline fun <reified T> membersOf() = T::class.members

fun main(s: Array<String>) {
    println(membersOf<StringBuilder>().joinToString("\n"))
}

普通的函数（未标记为内联函数的）不能有具体化参数。不具有运行时表示的类型（例如非具体化的类型参数或者类似于Nothing的虚构类型）不能用作具体化的类型参数的实参。

内联属性
inline 修饰符可用于没有幕后字段的属性的访问器。你可以标注独立的属性访问器：

val foo: Foo
    inline get() = Foo()

var bar: Bar
    get() = ……
    inline set(v) { …… }

你也可以标注整个属性，将它的两个访问器都标记为内联：

inline var bar: Bar
    get() = ……
    set(v) { …… }

在调用处，内联访问器如同内联函数一样内联。

当一个内联函数是 public 或 protected 而不是 private 或 internal 声明的一部分时，就会认为它是一个模块级的公有 API。可以在其他模块中调用它，并且也可以在调用处内联这样的调用。

附加内联函数的理解：

Kotlin中关于内联函数的一些理解分享
 Kotlin 内联函数与普通函数区别

查看kotlin编译字节码方法

Android Stuidio
Tools ->Kotlin->show Kotlin Bytecode