Kotlin使用Lambda简化匿名内部类

一、Lambda 简化演变

这篇文章是介绍 Kotlin 的 Lambda，而不是 Java 的，两者大体相似，但是在语法上略有不同。下面用三个例子（接口中抽象方法的参数，分别是无参数、单个参数、多个参数）来具体说明简化步骤：

先来看最原始的写法，不使用 Lambda 表达式

// 接口中的抽象方法无参数
Thread(object : Runnable {
    override fun run() {
        println("run")
    }
}).start()

// 接口中的抽象方法一个参数
button.setOnClickListener(object : View.OnClickListener {
    override fun onClick(v: View?) {
        v?.visibility = View.GONE
    }
})

// 接口中的抽象方法多个参数
AlertDialog.Builder(this).apply {
    setTitle("This is AlertDialog")
    setMessage("Message")
    setPositiveButton("OK", object : DialogInterface.OnClickListener {
        override fun onClick(dialog: DialogInterface?, which: Int) {
            println("Ok")
        }
    })
    setNegativeButton("Cancel", object : DialogInterface.OnClickListener {
        override fun onClick(dialog: DialogInterface?, which: Int) {
            println("Cancel")
        }
    })
    show()
}

由于 OnClickListener，Runnable 只有一个待实现的抽象方法，可以使用 Lambda 表达式省略方法名，在 -> 前定义参数，在 -> 后面定义函数体

Thread(Runnable { ->
    println("run")
}).start()

button.setOnClickListener(View.OnClickListener { v: View? ->
    v?.visibility = View.GONE
})

AlertDialog.Builder(this).apply {
    setTitle("This is AlertDialog")
    setMessage("Message")
    setPositiveButton(
        "OK",
        DialogInterface.OnClickListener { dialog: DialogInterface?, which: Int ->
            println("Ok")
        }
    )
    setNegativeButton(
        "Cancel",
        DialogInterface.OnClickListener { dialog: DialogInterface?, which: Int ->
            println("Cancel")
        }
    )
    show()
}

由于 Kotlin 具备类型推导机制，如果 Lambda 参数的类型可以被推导出来，可以省略参数类型

button.setOnClickListener(View.OnClickListener { v ->
    v?.visibility = View.GONE
})

AlertDialog.Builder(this).apply {
    setTitle("This is AlertDialog")
    setMessage("Message")
    setPositiveButton(
        "OK",
        DialogInterface.OnClickListener { dialog, which ->
            println("Ok")
        }
    )
    setNegativeButton(
        "Cancel",
        DialogInterface.OnClickListener { dialog, which ->
            println("Cancel")
        }
    )
    show()
}

没有参数可以省略 -> ；只有一个参数，并且未使用，可以省略参数和 -> ；多个参数未使用，不可以省略，可以使用 _ 占位进行简化

// 没有参数省略 ->
Thread(Runnable {
    println("run")
}).start()

// 只有一个参数 v ，并且未使用，可以省略
button.setOnClickListener(View.OnClickListener {
    println("onclick")
})

// 多个参数未使用，不可以省略，可以使用 _ 占位进行简化
AlertDialog.Builder(this).apply {
    setTitle("This is AlertDialog")
    setMessage("Message")
    setPositiveButton(
        "OK",
        DialogInterface.OnClickListener { _, _ ->
            println("Ok")
        }
    )
    setNegativeButton(
        "Cancel",
        DialogInterface.OnClickListener { _, _ ->
            println("Cancel")
        }
    )
    show()
}

由于 Thread()、 setOnClickListener()、setPositiveButton()、setNegativeButton() 这些方法中仅有一个接口参数，所以可以省略接口名称

Thread({ println("run") }).start()

button.setOnClickListener({ v -> v?.visibility = View.GONE })

AlertDialog.Builder(this).apply {
    setTitle("This is AlertDialog")
    setMessage("Message")
    setPositiveButton("OK", { _, _ -> println("Ok") })
    setNegativeButton("Cancel", { _, _ -> println("Cancel") })
    show()
}

如果 Lambda 参数是函数的最后一个参数，可以将 Lambda 参数移到小括号外面

Thread() { println("run") }.start()

button.setOnClickListener() { v -> v?.visibility = View.GONE }

AlertDialog.Builder(this).apply {
    setTitle("This is AlertDialog")
    setMessage("Message")
    setPositiveButton("OK") { _, _ -> println("Ok") }
    setNegativeButton("Cancel") { _, _ -> println("Cancel") }
    show()
}

如果 Lambda 参数是函数的唯一参数，可以将小括号省略

Thread { println("run") }.start()

button.setOnClickListener { v -> v?.visibility = View.GONE }

如果 Lambda 参数只有一个，可以不声明参数名，使用 it 关键字代替

button.setOnClickListener { it?.visibility = View.GONE }

到这里，简化的方式基本都介绍完了，Kotlin 能使用这种写法的原因是：优秀的类型推导机制 + Lambda 表达式。

二、Lambda 标准格式

Lambda 省去面向对象的条条框框，格式由3个部分组成：参数列表、箭头、函数体。

Kotlin 中的 Lambda 的标准语法结构是：参数名1: 参数类型, 参数名2: 参数类型 -> 函数体

格式说明：

没有参数时，参数列表留空；多个参数时，用逗号分隔。
-> 是新引入的语法格式，代表指向动作。
函数体大括号内的语法与传统方法体要求基本一致。

三、Lambda 省略格式

在 Lambda 标准格式的基础上，使用省略写法的规则为：

参数类型可以省略。
如果没有参数，可以省略 ->
如果参数没有在函数体中使用，可以使用 _ 简化参数
如果只有一个参数，并且没有在函数体中使用，可以省略参数和 ->

四、Lambda 使用前提

Lambda 使用时有几个问题需要特别注意：

使用 Lambda 必须具有接口，且要求接口中有且仅有一个抽象方法。
使用 Lambda 必须具有上下文推断。也就是方法的参数或局部变量类型必须为 Lambda 对应的接口类型，才能使用 Lambda 作为该接口的实例。

备注：有且仅有一个抽象方法的接口，称为“函数式接口”。