[toc]
了解内联函数前先了解下lambda表达式
lambda
Lambda表达式的本质其实是匿名函数，因为在其底层实现中还是通过匿名函数来实现的。但是我们在用的时候不必关心起底层实现。不过Lambda的出现确实是减少了代码量的编写，同时也是代码变得更加简洁明了。
使用
1. 无参数的情况 ：
val/var 变量名 = { 操作的代码 }
2. 有参数的情况
val/var 变量名 : (参数的类型，参数类型，...) -> 返回值类型 = {参数1，参数2，... -> 操作参数的代码 }
可等价于
// 此种写法：即表达式的返回值类型会根据操作的代码自推导出来。
val/var 变量名 = { 参数1 ： 类型，参数2 : 类型, ... -> 操作参数的代码 }
3. lambda表达式作为函数中的参数的时候，这里举一个例子：
fun test(a : Int, 参数名 : (参数1 ： 类型，参数2 : 类型, ... ) -> 表达式返回类型){
...
}
实例讲解
- 无参数的情况
// 源代码
fun test(){ println("无参数") }
// lambda代码
val test = { println("无参数") }
// 调用
test() => 结果为：无参数
- 有参数的情况
// 源代码
fun test(a : Int , b : Int) : Int{
return a + b
}
// lambda
val test : (Int , Int) -> Int = {a , b -> a + b}
// 或者
val test = {a : Int , b : Int -> a + b}
// 调用
test(3,5) => 结果为：8
- lambda表达式作为函数中的参数的时候
// 源代码
fun test(a : Int , b : Int) : Int{
return a + b
}
fun sum(num1 : Int , num2 : Int) : Int{
return num1 + num2
}
// 调用
test(10,sum(3,5)) // 结果为：18
// lambda
fun test(a : Int , b : (num1 : Int , num2 : Int) -> Int) : Int{
return a + b.invoke(3,5)
}
// 调用
test(10,{ num1: Int, num2: Int -> num1 + num2 }) // 结果为：18
T.()->Unit 、 ()->Unit的区别
- ()->Unit与(T) -> Unit是相同的，是lambda的函数参数形式，只是一个带参，一个不带参。(T) -> Unit通过形参T可将对象作为实参传给函数，所以函数体里能通过it或者指定名称的方式来访问该对象
- T.()->Unit 等同于为T定义了一个无参数的扩展函数，所以在函数体内可以直接通过this或省略来访问T代表的对象
实例讲解
(T) -> Unit
fun Person.alsoWithReceiver(block:(Person) ->Unit):Person{
block(this)
return this
}
//构造的参数是it
person.alsoWithReceiver {
it.setNewName("haha bro")
}.getOldName()
T.()->Unit
fun Person.ApplyNew(block:Person.() ->Unit):Person{
block()
return this
}
//构造的参数是this
person.ApplyNew {
this.setNewName("aa")
}
1.Let
1.1作用
- 使用it替代object对象去访问其公有的属性 & 方法
- 判断object为null的操作
1.2底层结构
public inline fun T.let(block: (T) -> R): R {
return block(this)
}
1.3使用方法
// 作用1：使用it替代object对象去访问其公有的属性 & 方法
object.let{
it.todo()
}
// 作用2：判断object为null的操作
object?.let{//表示object不为null的条件下，才会去执行let函数体
it.todo()
}
// 注：返回值 = 最后一行 / return的表达式
1.4实例讲解
// 使用Java
if( mVar != null ){
mVar.function1();
mVar.function2();
mVar.function3();
}
// 使用kotlin（无使用let函数）
mVar?.function1()
mVar?.function2()
mVar?.function3()
// 使用kotlin（使用let函数）
// 方便了统一判空的处理 & 确定了mVar变量的作用域
mVar?.let {
it.function1()
it.function2()
it.function3()
}
2.Also
2.1作用
类似let函数，但区别在于返回值：
let函数：返回值 = 最后一行 / return的表达式
also函数：返回值 = 传入的对象的本身
2.2底层结构
public inline fun T.also(block: (T) -> Unit): T {
block(this)
return this
}
2.3使用方法
// 作用1：使用it替代object对象去访问其公有的属性 & 方法
object.also{
//this 可省略
this.todo()
}
// 作用2：判断object为null的操作
object?.also{//表示object不为null的条件下，才会去执行let函数体
todo()
}
2.4实例讲解
// let函数
var result = mVar.let {
it.function1()
it.function2()
it.function3()
999
}
// 最终结果 = 返回999给变量result
// also函数
var result = mVar.also {
it.function1()
it.function2()
it.function3()
999
}.todo()
// 最终结果 = 返回一个mVar对象给变量result
3.with
3.1作用
调用同一个对象的多个方法 / 属性时，可以省去对象名重复，直接调用方法名 / 属性即可
3.2底层结构
public inline fun with(receiver: T, block: T.() -> R): R {
return receiver.block()
}
3.3使用方法
with(object){
// ...
}
// 返回值 = 函数块的最后一行 / return表达式
3.4 使用示例
3.4实例讲解
// 此处要调用people的name 和 age属性
// kotlin
val people = People("carson", 25)
with(people) {
this.setName("zhangsan")
setAge(15)
println("my name is $name, I am $age years old")
}
// Java
User peole = new People("carson", 25);
String var1 = "my name is " + peole.name + ", I am " + peole.age + " years old";
System.out.println(var1);
4.Run
4.1作用
结合了let、with两个函数的作用，即：
1. 调用同一个对象的多个方法 / 属性时，可以省去对象名重复，直接调用方法名 / 属性即可
2. 定义一个变量在特定作用域内
3. 统一做判空处理
4.2底层结构
public inline fun T.run(block: T.() -> R): R {
return block()
}
4.3使用方法
object.run{
// ...
}
// 返回值 = 函数块的最后一行 / return表达式
4.4实例讲解
// 此处要调用people的name 和 age属性，且要判空
// kotlin
val people = People("carson", 25)
people?.run{
println("my name is $name, I am $age years old")
}
// Java
User peole = new People("carson", 25);
String var1 = "my name is " + peole.name + ", I am " + peole.age + " years old";
System.out.println(var1);
5.Apply
5.1作用
与run函数类似，但区别在于返回值：
1. run函数返回最后一行的值 / 表达式
2. apply函数返回传入的对象的本身
5.2底层结构
public inline fun T.apply(block: T.() -> Unit): T {
block()
return this
}
5.3使用方法
object.apply{
// ...
}
// 返回值 = object
5.4实例讲解
// run函数
val people = People("carson", 25)
val result = people?.run{
println("my name is $name, I am $age years old")
999
}
// 最终结果 = 返回999给变量result
// Java
val people = People("carson", 25)
val result = people?.run{
println("my name is $name, I am $age years old")
999
}
// 最终结果 = 返回一个people对象给变量result