Lambda表达式 和 Extension 是Kotlin语言中两个非常漂亮的语法特性，两者联合起来使用常常会触发许多令人意想不到的化学效应；一旦你也熟悉了这两个语法，很容易爱上他们；
Ok, let's start...
Lambda表达式基础
先来熟悉一下Lambda表达式的基础知识！
Lambda翻译为中文有匿名函数的意思，不过，在Kotlin语言中，有专门的匿名函数语法；所以，二者一定要区分开来，这个知识点将在后面进行讲解。
Lambda表达式和匿名函数本质上依然是一个函数，可以认为是函数的一个变体；所有的函数都可以转换为Lambda表达式，所有的Lambda表达式也可以转换为函数；先看一个简单的例子：
// 这是一个简单的比较数字大小的函数
fun max(i: Int , j: Int): Boolean {
return i > j
}
// 转换为Lambda表达式
{i: Int , j: Int -> i > j}
从上面的例子我们很容易了解到Lambda表达式的三个基本要素:
- 代码块要放在大括号里面
- 使用->隔离变量和表达式
- 如果->后面的表达式会产生新的值，这个新值将作为该Lambda表达式的返回值；如果表达式有多行代码，并且有多行代码有返回值，将使用最后一行代码的返回值作为该Lambda表达式的返回值；
在使用过程中记住这三点就可以轻松地使用Lambda表达式；
理解简化版本的Lambda表达式
在日常使用过程中，我们经常可以看到一些极简的Lambda表达式，有些同学可能会误以为是不是代码写错了，或者根本就不是Lambda表达式；其实不然，来看一个简单的例子：
// 1) 简化表达式一
val sum: (Int , Int)->Int = {x , y -> x + y}
// 这个简化的Lambda表达式很容易理解，Kotlin语言支持类型推导，通过前面sum变量指定的参数类型，很容易推导出x,y均为Int类型，故类型参数可以省略掉;
// 2) 简化表达式二
ints.filter { it > 0 }
// 这个简化的Lambda表达式的确有点难以理解，Kotlin语言中有一个约定，如果Lambda表达式的参数只有一个，则可以省略参数声明语句；
// 举一反三
val cl: (Int)->Boolean = {x > 0}
// 这样写是否可以呢？答案是：不可以！
// 目前的Kotlin编译器不支持这样的写法，x必须修改为it；其实，按照逻辑来讲，我认为这样写也是合理的；当然，Kotlin团队可能也是为了规范单一参数Lambda表达式的统一。
匿名函数
Kotlin语言还支持匿名函数，事实上在开发过程中笔者很少使用匿名函数；不过为了保证文章的完整性，这里也做一个简单介绍！
看一个简单的例子：
// 该匿名函数主要用于判断整形x值是否大于0
val f: (Int)->Boolean = fun(x)->x > 0
匿名函数很好理解，即省略了函数名的函数而已！直接在fun关键字后面写形参。
至此，Lambda表达式的基础知识已经讲解完毕；下面开始笔者最喜欢的Kotlin语言特性Extension的讲解。
Extension翻译为中文的意思是扩展，以下简称扩展
扩展特性最早出现在OC语言中，OC的后继者Swift同样支持扩展特性；遗憾的是，在Java语言中，一直到Java1.8，扩展特性依然未获得支持；幸运的是，Kotlin语言支持该特性，Cheers!
Extension基础知识
在Java语言中，要对某个类进行扩展，在不改变原有类的基础上，只能使用继承实现；Kotlin语言可以在不使用继承的情况下对类进行扩展，即添加新的属性或者方法。
来看一个简单的例子：
// 使用下面的代码为String类新增了一个方法，该方法通过指定时间的格式，可以将时间字符串转化为时间戳
fun String.toTimeInMillis(pattern: String): Long {
var date: Date? = null
try {
val formatter = SimpleDateFormat(pattern , Locale.getDefault())
date = formatter.parse(this)
} catch(e: Exception) {
}
return date?.time ?: 0
}
// 在使用的时候，我们可以直接按照如下的方式调用:
val time = "2016-11-01 11:30:30".toTimeInMillis("yyyy-MM-dd HH:mm:ss")
// 是不是非常漂亮？-_-
扩展中有一个非常重要的概念就是：Receiver
Receiver又可以分为dispatch receiver和extension receiver
dispatch receiver: 即扩展声明所在的实体类；换而言之，扩展在哪个类中声明；，那么，该类就叫做该扩展的dispatch receiver
extension receiver: 调用扩展方法的具体的实体类类型；概念有点类似于多态。
来看一个具体的例子：
// 直接引用官方例子
open class D {
}
class D1 : D() {
}
open class C {
open fun D.foo() {
println("D.foo in C")
}
open fun D1.foo() {
println("D1.foo in C")
}
fun caller(d: D) {
d.foo() // call the extension function
}
}
class C1 : C() {
override fun D.foo() {
println("D.foo in C1")
}
override fun D1.foo() {
println("D1.foo in C1")
}
}
C().caller(D()) // prints "D.foo in C"
C1().caller(D()) // prints "D.foo in C1" - dispatch receiver is resolved virtually
C().caller(D1()) // prints "D.foo in C" - extension receiver is resolved statically
来做一个简单的分析：
<code>C1().caller(D())</code> : 这句代码中，dispatch receiver是C1, extension receiver是D1。实际调用的方法是C1类中声明的D的扩展方法foo。这说明dispatch receiver是动态执行的，或者说会根据运行时类型决定调用的扩展方法类型。
再来看这行代码 <code>C().caller(D1())</code> : 这句代码中，dispatch receiver是C，extension receiver是D1，实际调用的方法确实C类中声明的D的扩展方法。这里其实同样说明了上面的道理，即实际调用的扩展方法类型是动态执行的，而extension receiver是静态解析的，即不会根据编译时类型动态改变。
按照上面的分析理解，的确有点抽象，为此笔者使用下面一句话概括：
** 实际调用的扩展方法由dispatch receiver决定，即最终寻找扩展方法的顺序应该是从具体的dispatch receiver中查找该方法，如果没有找到则往父类中找。**
实际使用过程中，如果出现比较复杂的receiver类型，请来查阅这篇文章的这个部分。
尾随闭包
这个概念在Kotlin的官方文档中并没有明确说明，这里我引用Swift语言中的一个相同概念来表示它。这里可以认为是一个函数写法的变种，即：如果函数的最后一个参数是Lambda表达式，函数调用的时候参数可以写到函数的括号后面；看下面的例子：
fun lock(force: Boolean , lock: ()->Unit) {
}
// 可以用下面的方式调用:
lock(false) {
}
至此，Lambda和Extension的基础知识点就讲完了；来看一看在Android开发中，他们发挥怎样的作用！
举一个常见的例子，在Android开发中，经常需要在Activity或者Fragment中使用<code>Toast.makeText(this , Hello,world" , Toast.LENGTH_LONG).show()</code>
为了简化调用，很多同学使用下面的方式简化调用：
class ToastUtil {
public static void toast(Context context , Charsequence text , int length) {
Toast.makeText(context , text , length)
}
}
在Kotlin语言中，可以通过扩展使用非常优雅的方式解决这个问题，看代码：
fun Activity.toast(text: Charsequence? , length: Int = Toast.LENGTH_SHORT) {
Toast.makeText(this , text , length).show()
}
// 通过上面的扩展方法，在Activity中就可以直接使用
toast("Hello, world")
同样，也可以为Fragment添加扩展：
fun Fragment.toast(text: Charsequence? , length: Int = Toast.LENGTH_SHORT) {
Toast.makeText(activity , text , length).show()
}
怎么样，是不是比Java语言的实现方式优雅了许多？
不服？来看点更屌的！
在Android开发中，很多资源使用后必须记得关闭，比如数据库、IO流等等。在日常使用中，常常有人会忘记手动调用close方法关闭资源，为了避免这个问题，Java语言的解决方案可以使用一个方法帮助开启和关闭资源。以数据库为例，看下面的代码：
// Java语言实现
public void addUser(User user) {
SQLiteDatabase db = SQLiteOpenHelper.get(xxx);
// 这里写逻辑
db.close
}
Java语言的这种实现方式的确可以解决这个问题，但不够完全，它仅仅解决了addUser的问题；如果是删除用户，就必须新加一个方法去解决这个问题。有没有一种通用的方式来解决这个问题呢？答案是：有！不过Java语言实现起来比较麻烦，这个技术有一个专业名词叫AOP,即面向切面编程，需要通过Java语言的反射特性来实现该逻辑。使用反射实现通常是一个比较繁琐的逻辑了，在Kotlin语言中我们可以使用Lambda表达式和扩展轻松实现，看下面的代码:
fun use(func: SQLiteDataBase.()->Unit) {
func.invoke()
close()
}
use {
// 这里可以使用SQLiteDataBase的任意代码
}
通过上面的方法在使用完SQLite数据库后，就帮助你自动关闭了。这种使用方法还可以进行延伸，比如：
fun <T> lock(lock: Lock, body: () -> T): T {
lock.lock()
try {
return body()
} finally {
lock.unlock()
}
}
在Android开发中，对话框是必不可少的组件；可是，每次创建对话框确实一件比较麻烦的事情；为此，Java程序员常常在Android代码中使用DialogFactory创建各种对话框，这的确减少了很多繁琐的代码。可并不是特别漂亮，不妨来看一看Kotlin语言的解决方案:
fun Context.dialog(message: CharSequence , init: (Dialog.()->Unit)? = null): Dialog {
val dialog = Dialog(this)
dialog.message(message)
if(null != init) {
dialog.init()
}
return dialog
}
看起来并没有什么特殊之处；可是，在使用的时候，却看起来非常漂亮，请看下面的调用方法：
// 假设在Activity类中
dialog("Hello, kotlin") {
positiveButton("确定") {
dissmiss()
}
// 这里可以使用Dialog类的所有api
setCanceledOnTouchOutside(false)
}.show()
欢迎加入Kotlin交流群
如果你也喜欢Kotlin语言，欢迎加入我的Kotlin交流群： 329673958 ，一起来参与Kotlin语言的推广工作。
