函数、高阶函数、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代表执行此函数并返回值100val 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 = 0for (i in ints){counts+=i}logDebug("counts == $counts")//invoke代表执行此函数并返回值100val result = qux.invoke()return (2 * x)+result}//调用double(x=1, qux = {logDebug("函数体")100}, ints = intArrayOf(1,2,3))

局部函数

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

    fun af(){val age = 10fun bf(cc:Int){val agec = age+cclogDebug("年龄：$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 { // 隐式标签 @Ainner class B { // 隐式标签 @Bfun Int.foo() { // 隐式标签 @fooval a = this@A // A 的 thisval b = this@B // B 的 thisval c = this // foo() 的接收者，一个 Intval 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 + iprintln("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) -> Unitfun 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 = parentwhile (p != null && p !is T) {p = p.parent}return p as T?
}

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

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

inline fun <reified T> membersOf() = T::class.membersfun main(s: Array<String>) {println(membersOf<StringBuilder>().joinToString("\n"))
}

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

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

val foo: Fooinline get() = Foo()
​
var bar: Barget() = ……inline set(v) { …… }

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

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

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

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

附加内联函数的理解：

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

查看kotlin编译字节码方法

Android Stuidio
Tools ->Kotlin->show Kotlin Bytecode