函数、高阶函数、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
具体化的类型参数
如果你希望把
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