[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的区别

1. ()->Unit与(T) -> Unit是相同的，是lambda的函数参数形式，只是一个带参，一个不带参。(T) -> Unit通过形参T可将对象作为实参传给函数，所以函数体里能通过it或者指定名称的方式来访问该对象
2. 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作用

1. 使用it替代object对象去访问其公有的属性 & 方法
2. 判断object为null的操作

1.2底层结构

public inline fun <T, R> 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> 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 <T, R> 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, R> 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> 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