介绍

Kotlin在原本的语法糖(Syntactic sugar)中加入了很多有意思的语法，让编程看起来更加顺畅，更加简洁，方便阅读。

Lambda

通常一个简单函数，可以使用Lambda来定义函数：

var addValue：定义变量
(Int,Int) ->Int：定义变量的类型，接收两个Int，返回Int
{x,y->x+y}：定义变量的值

fun test() {
      var addValue: (Int, Int) -> Int = { x, y -> x + y }
      var result = addValue(10, 20)
}

函数与代码块

在函数定义中，也可以使用代码块以及Lambda来定义，让函数定义与使用更加赏心悦目。

下面的代码在test函数中定义了两个Int的参数，以及一个名为block的代码块参数。而这个block则不传递任何参数，并且会返回String类型的结果。

class GardenPlant {

    fun main() {
        test(n = 10, m = 1) {
            "Hello World"
        }
    }

    fun test(m: Int, n: Int, block: () -> String) {
        println(block())
        print("m:$m....n:$n")
    }
}

而有意思的是，当函数的参数最后是一个代码块的时候，Kotlin允许使用Lambda来代替参数，也就不需要写在参数列表中了。

函数与多参数代码块

在函数的参数中，也可以使用<T>来标识泛型。在编译器处理的过程中，会将泛型擦除，编译的时候，会是具体的类型。
例如，在编译的时候，下述test的代码块中，x``就已经标识为了String```类型。

而在block:(T,int) ->R这一句话中，代表了代码块中可以接受两个参数，并且返回R类型的结果。
在使用test函数的地方，可以看到这个Lambda语句中x,y->代表了接收的两个参数，x类型为T，y类型为Int类型。

class GardenPlant {

    fun main() {
        test("Test") { x, y ->
            if (x == "Test") {
                y
            } else {
                0
            }
        }
    }

    fun <T, R> test(value: T, block: (T, Int) -> R): GardenPlant {
        val result = block(value, 20)
        println(result)
        return this
    }
}

函数与扩展函数的使用

对于扩展函数的使用，Kotlin也支持泛型，并且可以支持两种扩展函数如下：

test函数中，使用T.test来定义泛型的扩展函数，并且block:(T)->R定义了接收参数T的代码块，并且返回R对象，在test的代码块中，可以自己定义参数或者使用it来接收参数。

test2函数中，使用block:T.()->R来定义T的扩展函数，并且返回R，而在test2的代码块中可以使用this来引用对象。

class GardenPlant {
    lateinit var plantName: String

    fun main() {
        val plant = GardenPlant()
        plant.test(plant) { p ->
            p.plantName
        }
    }

    fun <T, R> T.test(value: GardenPlant, block: (T) -> R): R {
        return block(this)
    }

    fun <T, R> T.test2(value: GardenPlant, block: T.() -> R): R {
        return block()
    }

}