Kotlin难点
高阶函数
高阶函数是将函数用作参数或返回值的函数, 还可以把函数赋值给一个变量。
所有函数类型都有一个圆括号括起来的参数类型列表以及一个返回类型：(A, B) -> C 表示接受类型分别为 A 与 B 两个参数并返回一个 C 类型值的函数类型。参数类型列表可以为空，如 () -> A，Unit 返回类型不可省略。
(Int) -> String
函数类型表示法可以选择性地包含函数的参数名：(x: Int, y: Int) -> Point。这些名称可用于表明参数的含义。
(Button, ClickEvent) -> Unit
如需将函数类型指定为可空，请使用圆括号：((Int, Int) -> Int)?
fun a(funParam: (Int) -> String): String {
return funParam(1)
}
fun b(param: Int): String {
return param.toString()
}
调用
a(::b)
var d = ::b
b(1) // 调用函数
d(1) // 实际上会调用 d.invoke(1)
(::b)(1) // 用对象 :: b 后面加上括号来实现 b() 的等价操作, 实际上会调用 (::b).invoke(1)
b.invoke(1) // 报错
对象是不能加个括号来调用的，但是函数类型的对象可以。为什么？因为这其实是个假的调用，它是 Kotlin 的语法糖，实际上你对一个函数类型的对象加括号、加参数，它真正调用的是这个对象的 invoke () 函数
双冒号
:: 创建一个函数引用或者一个类引用
函数引用
fun isOdd(x: Int) = x % 2 != 0
我们可以很容易地直接调用它（isOdd (5)），但是我们也可以将其作为一个函数类型的值，例如将其传给另一个函数。为此，我们使用 :: 操作符：
val numbers = listOf(1, 2, 3)
println(numbers.filter(::isOdd))
这里 :: isOdd 是函数类型 (Int) -> Boolean 的一个值。
在类外面，如果我们需要使用类的成员函数或扩展函数，它需要是限定的，例如 String:: toCharArray。
val args: Array<String> = arrayOf("1", "2")
args.filter(String::isNotEmpty)
class PdfPrinter {
fun println(any: Any) {
kotlin.io.println(any) //重名了可以用包名调用
}
}
val pdfPrinter = PdfPrinter()
args.forEach(pdfPrinter::println)
类引用
val c = MyClass::class
该引用是 KClass 类型的值
请注意，Kotlin 类引用与 Java 类引用不同。要获得 Java 类引用，请在 KClass 实例上使用 .java 属性。
平时写的类，其信息都可以在这个 KClass 来获取
属性引用
data class MediaItem(val title: String, val url: String)
var items= mutableListOf<MediaItem>()
items
.sortedBy { it.title }
.map { it.url }
.forEach { print(it) }
items
.sortedBy(MediaItem::title)
.map(MediaItem::url)
.forEach(::println)
匿名函数
没有名字的函数
要传一个函数类型的参数，或者把一个函数类型的对象赋值给变量，除了用双冒号来拿现成的函数使用，你还可以直接把这个函数挪过来写：
fun b(param: Int): String {
return param.toString()
}
a(fun b(param: Int): String {
return param.toString()
});
val d = fun b(param: Int): String {
return param.toString()
}
//名字没意义，省略
a(fun(param: Int): String {
return param.toString()
});
val d = fun(param: Int): String {
return param.toString()
}
如果你在 Java 里设计一个回调的时候是这么设计的：
public interface OnClickListener {
void onClick(View v);
}
public void setOnClickListener(OnClickListener listener) {
this.listener = listener;
}
使用的时候是这么用的：
view.setOnClickListener(new OnClickListener() {
@Override
void onClick(View v) {
switchToNextPage();
}
});
kotlin 写法
fun setOnClickListener(onClick: (View) -> Unit) {
this.onClick = onClick
}
view.setOnClickListener(fun(v: View): Unit) {
switchToNextPage()
})
Lambda 写法：
view.setOnClickListener({ v: View ->
switchToNextPage()
})
Lambda 表达式
简化匿名函数，代码更简洁
view.setOnClickListener({ v: View ->
switchToNextPage()
})
//如果 Lambda 是函数的最后一个参数，你可以把 Lambda 写在括号的外面：
view.setOnClickListener() { v: View ->
switchToNextPage()
}
//而如果 Lambda 是函数唯一的参数，你还可以直接把括号去了：
view.setOnClickListener { v: View ->
switchToNextPage()
}
//另外，如果这个 Lambda 是单参数的，它的这个参数也省略掉不写：
//根据上下文推导，根据最后一行代码来推断出返回值类型
view.setOnClickListener {
switchToNextPage()
}
Lambda 表达式的完整语法形式如下：
val sum: (Int, Int) -> Int = { x: Int, y: Int -> x + y }
val sum = { x: Int, y: Int -> x + y }
多参数例子：
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 表达式的参数类型是可选的，如果能够推断出来的话：
val joinedToString = items.fold("Elements:", { acc, i -> acc + " " + i })
输出：
acc = 0, i = 1, result = 1
acc = 1, i = 2, result = 3
acc = 3, i = 3, result = 6
acc = 6, i = 4, result = 10
acc = 10, i = 5, result = 15
joinedToString = Elements: 1 2 3 4 5
总结
函数不能直接传递或者赋给某个变量，需要函数类型实例化，有三种方式：
使用已有声明的可调用引用
- 函数引用
使用函数字面值的代码块
- 匿名函数
- lambda 表达式
例子
实现接口
var onVideoStartCallBack: (() -> Unit)? = null
onVideoStartCallBack?.invoke()
videioView.onVideoStartCallBack = {
}
函数里实现接口
object UploaderListHelper {
fun startTaskUpload(activity: Activity, startCallBack: ((Int) -> Unit)?) {
startCallBack.invoke(position)
}
}
UploaderListHelper.startTaskUpload(activity) {
refreshProgress(it)
}
闭包就是 Lambda 表达式
lambda 表达式，通常是在需要一个函数，但是又不想去命名一个函数的场合下使用，也就是匿名函数。而 Lambda 可以简化匿名函数，使代码更加简洁。也可以将一个代码块赋值给一个变量，在调用方法的时候，可以直接将这个 lambda 表达式当作参数传递进去
kotlin 接口回调，省了个方法定义
private lateinit var delListener: ((Boolean, DiseaseBean) -> Unit)
fun setDelListener(delListener: ((Boolean, DiseaseBean) -> Unit)) {
this.delListener = delListener
}
delListener?.invoke(holder.btDel.isChecked, tagBean)
更简单，传个方法，接口都不用写了
mcDiagnosisType.showLayout {
if(it){ //it 就是boolean
mcDiseaseType.animateClose()
}
}
fun showLayout(callBack :(((Boolean)->Unit))?=null){
if(isShow){
animateClose()
callBack?.invoke(isShow)
}else{
animateOpen()
callBack?.invoke(isShow)
}
}
作用域函数
Kotlin 标准库包含几个函数，它们的唯一目的是在对象的上下文中执行代码块。当对一个对象调用这样的函数并提供一个 lambda 表达式时，它会形成一个临时作用域。在此作用域中，可以访问该对象而无需其名称。这些函数称为作用域函数。共有以下五种：let、run、with、apply 以及 also。
这些函数基本上做了同样的事情：在一个对象上执行一个代码块。不同的是这个对象在块中如何使用，以及整个表达式的结果是什么。
目的：简洁
val person = findPerson();
//person是可null的，所以需要？
println(person?.age)
println(person?.name)
//上面太麻烦，findPerson加了？,所以后面不需要了,减少的判空操作。let可以安全调用
findPerson()?.let { person ->
person.work()
println(person.age)
}
//还可以更简洁，person也不用写
findPerson()?.apply {
work()
println(age)
}
使⽤时可以通过简单的规则作出一些判断
返回自身
返回值是它本身
从 apply 和 also 中选
作⽤域中使⽤ this 作为参数选择 apply
val adam = Person("Adam").apply {
age = 32
city = "London"
}
println(adam)
作⽤域中使⽤ it 作为参数选择 also
val numbers = mutableListOf("one", "two", "three")
numbers
.also { println("The list elements before adding new one: $it") }
.add("four")
with 非扩展函数
val numbers = mutableListOf("one", "two", "three")
with(numbers) {
println("'with' is called with argument $this")
println("It contains $size elements")
}
不需要返回自身
从 run 和 let 中选择
作用域中使用 this 作为参数，选择 run
作用域中使用 it 作为参数，选择 let, 适合配合空判断的时候
val service = MultiportService("https://example.kotlinlang.org", 80)
val result = service.run {
port = 8080
query(prepareRequest() + " to port $port")
}
// 同样的代码如果用 let() 函数来写:
val letResult = service.let {
it.port = 8080
it.query(it.prepareRequest() + " to port ${it.port}")
}
it 作为参数的好处
let 允许我们自定义参数名字，使可读性更强，如果倾向可读性可以选择 T.let
委托机制
Kotlin 中的委托是一种抽象的设计模式，允许将工作委托给另一个对象处理。在 Kotlin 中委托分为两种类型: 类委托和属性委托
类委托
类委托的核心思想在于将一个类的具体实现委托给另一个类完成。通过使用类委托，可以将某些特定行为委托给其他类处理，从而实现代码的解耦和重用。类委托的使用害要创建实现了特定接口或继承了抽象类的类，并将其作为委托对象传递给需要处理的对象。
// 约束类
interface IGamePlayer {
// 打排位赛
fun rank()
// 升级
fun upgrade()
}
// 委托对象
class DelegateGamePlayer(private val player: IGamePlayer): IGamePlayer by player
// Client 场景测试
fun main() {
val realGamePlayer = RealGamePlayer("张三")
val delegateGamePlayer = DelegateGamePlayer(realGamePlayer)
delegateGamePlayer.rank()
delegateGamePlayer.upgrade()
}
属性委托
属性委托则是将属性的 getter 和 setter 方法逻辑委托给另一个类实现。属性委托允许将属性的读取和设置逻辑放在另一个地方处理，比如更改属性名称或延迟初始化等场景。通过使用属性委托，可以将属性的逻辑封装在一个类中并在需要时将其传递给其他对象使用
val 属性实现 ReadOnlyProperty，var 属性实现 ReadOnlyProperty。
// val 属性委托实现
class Delegate1: ReadOnlyProperty<Any,String>{
override fun getValue(thisRef: Any, property: KProperty<*>): String {
return "通过实现ReadOnlyProperty实现，name:${property.name}"
}
}
// var 属性委托实现
class Delegate2: ReadWriteProperty<Any,Int>{
override fun getValue(thisRef: Any, property: KProperty<*>): Int {
return 20
}
override fun setValue(thisRef: Any, property: KProperty<*>, value: Int) {
println("委托属性为： ${property.name} 委托值为： $value")
}
}
// 测试
class Test {
// 属性委托
val d1: String by Delegate1()
var d2: Int by Delegate2()
}
内联函数
内联函数 inline
高阶函数实现的原理：函数类型其实是生成了一个对象
使用 inline 能避免函数的 lambda 形参额外创建 Function 对像
- kotlin 源码里使用了很多的内联函数，它的作用简单来说就是方便进行类型推导，能具体化类型参数。
- 被 inline 标记的函数就是内联函数, 其原理就是:在编译时期, 把调用这个函数的地方用这个函数的方法体进行替换
inline fun <T> method(lock: Lock, body: () -> T): T {
lock.lock()
try {
return body()
} finally {
lock.unlock()
}
}
method (lock, {"我是 body 方法体"})//lock 是一个 Lock 对象
其实上面调用的方法, 在编译时期就会把下面的内容替换到调用该方法的地方, 这样就会减少方法压栈, 出栈, 进而减少资源消耗;
lock.lock()
try {
return "我是body方法体"
} finally {
lock.unlock()
}
也就是说 inline 关键字实际上增加了代码量，但是提升了性能，而且增加的代码量是在编译期执行的，对程序可读性不会造成影响。
inline 的坏处：
- 对于一个 public 的 inline 方法，他不可以引用类的私有变量。
- inline 关键字对于 lambda 的处理有的时候不是我们想要的， inline 函数的形参 lambda 不能有 return 语句，避免 lambda 中的 return 影响外部程序流程
fun main(args: Array<String>) {
println("Start of main")
multiplyByTwo(5) {
println("Result is: $it")
return
}
println("End of main")} //不会执行，有问题
总结
- 使用 inline，内联函数到调用的地方，能减少函数调用造成的额外开销，在循环中尤其有效
- 使用 inline 能避免函数的 lambda 形参额外创建 Function 对象
- 使用 noinline 可以拒绝形参 lambda 内联
- 使用 crossinline 显示声明
inline 关键字的作用，是把 inline 方法以及方法中的 lambda 参数在编译期间复制到调用方，进而减少函数调用以及对象生成。对于有时候我们不想让 inline 关键字对 lambda 参数产生影响，可以使用 noline 关键字。如果想 lambda 也被 inline，但是不影响调用方的控制流程，那么就要是用 crossinline。
Lambda 表达式不允许使用 return，除非这个 Lambda 表达式是内联函数的参数。
(Function1）null. INSTANCE，是由于反编译器工具在找不到等效的 Java 类时的显示的结果。
Kotlin的inline noinline crossinline笔记 - 简书
Kotlin inline noinline crossinline 解答 - 掘金
Reified
- 由于 Java 中的泛型存在类型擦除的情况，任何在运行时需要知道泛型确切类型信息的操作都没法用了。比如你不能检查一个对象是否为泛型类型 T 的实例，所以需要反射。
- 而 reified，字面意思：具体化，其实就是具体化泛型。
- 主要还是有内联函数 inline, 才使得 kotlin 能够直接通过泛型就能拿到泛型的类型，只有内联函数的类型参数可以具体化。
[[泛型#泛型擦除]]
例子
定义实现一个扩展函数启动 Activity，一般都需要传 Class< T > 参数：
// Function
private fun <T : Activity> Activity.startActivity(context: Context, clazz: Class<T>) {
startActivity(Intent(context, clazz))
}
// Caller
startActivity(context, NewActivity::class.java)
使用 reified，通过添加类型传递简化泛型参数
// Function
inline fun <reified T : Activity> Activity.startActivity(context: Context) {
startActivity(Intent(context, T::class.java))
}
// Caller
startActivity<NewActivity>(context)
