Kotlin高级语法

委托

类委托

当一个类继承于另一个类或者实现某个接口，我们需要在该类中重写或者实现对应的方法，为了代码简练或者其他原因我们会用到委托的思想，也就是让别的类来帮助我们完成这些事情，在Kotlin中对委托进行了原生的支持，用by关键字实现。
```
//将Collection的方法委托给c对象完成
class DelegateCollection<T>(val c: Collection<T>) : Collection<T> by c {}
```
属性委托

类里面的某个成员属性也可以通过by关键字进行委托实现，但实际上只是将该属性的选择器委托给了另外一个对象也就是getter/setter，因此被委托者必须具有getValue/setValue方法。
```
class Main{
   val p by Delegate()
   inner class Delegate {
      operator fun getValue(): Any {
          TODO()
      }
  }
}
```

懒加载

懒加载其实是一个非常实用的初始化方式，他会在被使用到的地方进行实例的初始化，把一些不用立刻使用的数据放到懒加载中可以提高页面整体的运行速度。通过by lazy进行懒加载委托。

//这样就会在用到num的地方调用getNum方法，并将返回值赋给num
//这里其实是个lambda表达式，传过去的其实是个代码块，所以理论上可以通过任意形式返回任何对象，如方法，构造函数，代码块等等。
//并且默认情况下是线程安全的，如果需要可以设置使用哪个锁
val num by lazy{ getNum() }

Lambda

lambda表达式，简称为lambda，本质上就是可以传递给其他函数的一小段代码。原生Java语言在Java8的时候引入了lambda的概念，kotlin中进一步加深了对lambda的支持。

意义

在代码中存储和传递一小段行为是常有的任务，但是以往的Java中并不支持直接传递代码，因此我们通常会使用实现抽象类和接口的方式创建一个匿名内部类来完成代码的传递，例如：

button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                log("onClick")
            }
        });

这时候我们会想，要是能够直接传递方法或者代码就好了，因此便有了lambda：

button.setOnClickListener {
    log("onClick")
}

看到这里可能很多人就懵逼了，就算是lambda为什么可以写成这样，其实是因为函数的参数中有且只有一个lambda表达式时，是可以省略普通函数中填写参数的()的。并且当lambda表达式本身没有形参或者没有被使用时也可以省略。所以完整写法其实应该是这样的：

fun Button.setOnClickListener((this) -> Unit)
button.setOnClickListener(){
    view->log("onClick")
}

这样看着是不是就觉得正常多了。

通过lambda我们将一段代码（行为）通过参数的形势注入给了方法，省去了以往定义和实现抽象类/接口的过程，而是用最直接有效的方式完成了操作。

语法

lambda本质上是一段行为，因此也有它固定的语法规则，在我们以往的习惯中任何行为都是由两部分组成：参数，结果。也就是形参和返回类型，这这里我们用()来表示形参，通过->连接行为最后的返回值。
```
(Int,Int) -> Int
参数1   参数2    返回/行为
```

如前所述，一个lambda把一小段行为进行编码，你能把他当做值进行传递，它可以被独立地声明并存储到一个变量中。如下：

val sum = { x:Int,y:Int -> x+y }
or
val sum:(Int,Int)->Int{x,y->x+y}//将声明行为独立出来，后面智能识别
log("2+3=${sum(2,3)}")
打印：2+3=5

上面演示了最简单的带参数和返回类型的行为，那么就需要传递一串代码块呢，和上述基本语法相同，其实传递代码块无非是一种特殊的行为，它特殊的地方在于不需要形参，也没有返回值。熟悉Kotlin的话你马上就能反应过来，没有返回值也就是Unit。因此如下：
```
  /**
   * 统一管理请求判断
   */
  private fun connect(operation: () -> Unit) =
          with(connection) {
              try {
                  kotlin.run(operation)
              } catch (e: Exception) {
                  when (e) {
                      is InterruptedIOException -> log("停止线程")
                      else ->  e.printStackTrace()
                  }
              } finally {
                  disconnect()
              }
          }
```
如上通过operation: () -> Unit传入了一段代码块用operation表示，在方法体中通过kotlin.run(operation)方法来执行该代码块。这样就完成了一个简单的异常拉取以及判断，在很多需要判断异常的地方直接调用该方法并传入代码块就能实现预期的效果，极大的提高的效率和代码可读性，也抽离了异常判断进行统一管理。

提升

上面讲的都是教你怎么用，而实际上你可能并没有理解他真正的表现形式，就像面向对象一样，是一个很抽象的概念，很多人用了多很年也没有彻底理解面向对象到底是个什么东西。拿我自己来说，刚开始的时候看着也是一脸懵逼，是的，确实能用了而且也没有什么大问题，但是让我说出为什么这样写的时候还是无法表达出来，这就是仅仅停留在会用层面上，接下来我会结合最近一段时间的使用来说明具体的理解。
不同场景结构解析
- 首先lambda是一种表达式，他像方法一样具有参数和返回(方法体)。这里为什么分别说具有参数、返回和方法体呢。因为lambda的表达式是(xxx)->xxxx这样的，它由两个部分组成，当它作为参数被定义的时候，它具有的是参数和返回，当它作为值被传入的时候，它具有的是参数和方法体。例如：
```
val sum: (Int,Int) -> Int = { x, y -> x + y}
```
这行代码严格说是包含了两段lambda表达式，(Int,Int) -> Int是作为参数的定义被使用的，所以包含的是参数和返回类型，x, y -> x + y是作为值来使用的，所以包含的是参数和方法体。
用法进阶
- lambda表达式主要有两种用法，一种用于方法传参，另外一种用于变量定义。前者很容易理解，但是后者很多人包括很多相关书籍也没有写出这样设计的目的是什么，只是单纯告诉了有这种用法。
```
//方法传参
button.setOnClickListener { view -> log("onClick") }
//变量定义
val sum: (Int,Int) -> Int = { x, y -> x + y}
```
- 拿最简单的例子按钮点击事件监听来说明，在Java的时候当我们需要传递一串代码或者行为我们通过编写相应的接口并且实现来完成的。在有了lambda之后，我们可以更简单的直接编写一种lambda表达式来表示和传递行为，也就是可以看成匿名接口的一种简单实现。
```
button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                log("onClick")
            }
        });
button.setOnClickListener ({ view ->
            log("onClick") 
})
```
- 那么，既然是接口，我们通常的直接将代码块传入lambda表达式就可以看成是匿名内部类的写法，相当于创建了一个实现了lambda表达式的匿名内部类。既然有匿名内部类，那么也可以让普通类去实现该lambda表达式。
- 当将一个lambda表达式赋值给一个变量时，这时该变量充当的就相当于是lambda表达式的实现类对象。在需要重复使用该表达式时我们就可以将其提出单独声明，然后重复传入对应的方法。
```
val clickEvent:(View)-> Unit = {view -> log("onClick")}
button.setOnClickListener (clickEvent)
button2.setOnClickListener(clickEvent)
```
- 同时这样也让我们对变量式的lambda表达式有了更深了理解，例如之前很多人不能理解为什么变量里面的表达式参数不用赋值就能直接使用。现在再来理解就容易的多，因为变量式的表达式只是一种表达式的“实现类”，本身没有具体的值，只是定义了当拿到了具体的值后应该怎么做的行为规则。

内联

正如上面我们的将lambda的实现比喻成接口的实现，而实际上，在Java中本质上也就是将每个lambda表达式编译成了一个个的匿名内部类或其他类的对象来使用的。因此如果频繁的使用lambda则会创建出无数个对象，这会带来运行时额外的开销。
针对这种情况，kotlin定义了一种新的关键字inline(内联)。简单来说就是被该关键字所修饰的函数所使用的lambda表达式不会被编译成新的对象，而是将表达式包含的真是代码替换到对应的函数中去，实现真正的代码块传递。

inline fun Boolean.isTrue(operation: () -> Unit) {
    if (this) {
        kotlin.run(operation)
    }
}

运行时泛型reified

泛型是一种增加代码拓展性常见的使用方式。但是我们知道因为系统不知道泛型具体代表的是哪个类型，所以我们是不能直接在代码中获得该类型的属性的。这么说可能很抽象，下面举个例子：
```
fun <T> getClassName(t: T) = t::class.java.name
```
我们通过该方法直接获得某个类的名称，从逻辑上是没毛病的，但是因为系统不能确定这个类，所以不允许这种写法。
在内联函数中，我们的函数会直接被编译成代码块放到对应的流程中去使用，因此其实这时候代码是知道传入的类型具体是什么东西的。所以以上的方法在内联函数中是可行的。这时只需要添加一个关键字reified。
```
inline fun <reified T> getClassName() = T::class.java.name
```

有了运行时泛型后给了我们代码更多的可能性，以下是简单的应用之一：

/**
* Activity 跳转
*/
inline fun <reified T> Activity.startActivity() {
  startActivity(Intent(this, T::class.java))
}
//跳转到NextActivity
startActivity<NextActivity>()

Kotlin高级语法

Kotlin高级语法

委托

Lambda

意义

语法

提升

内联

运行时泛型reified

猜你喜欢