×
广告

[Kotlin] Lambda and Extension

96
欧阳锋
2016.12.26 17:47* 字数 2031

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语言的推广工作。

Kotlin
Web note ad 1