Kotlin进阶-高阶函数进阶演变之路

·  阅读 537
Kotlin进阶-高阶函数进阶演变之路

持续创作,加速成长!这是我参与「掘金日新计划 · 6 月更文挑战」的第13天,点击查看活动详情

前言

很多同学刚接触Kotlin,或者一直以Java的方式写Kotlin,对Kotlin中的 高阶函数,扩展函数,高阶扩展函数,SamType, DSL 的一些写法不熟悉。这里以一个例子来说明一下如何进阶演变。

一、扩展函数

Kotlin中的扩展函数特性让我们的代码变得更加简单和整洁,它可以减少很多的样板代码,大大提高开发的效率。

我们常用的就是定义在顶层的扩展函数,如:

fun Any.toast(msg: String?) {
    ToastUtils.makeText(CommUtils.getContext(), msg)
}

虽然用的最多的都是顶层的扩展函数,但是扩展函数还是能限定作用域

fun String.foo() {
    YYLogUtils.w("扩展函数 foo1")
}

class TestNet {

    fun String.foo() {
        YYLogUtils.w("扩展函数 foo2")
    }
}

那么在类部使用和类外使用调用的是不同的方法。

除了扩展函数,我们还能扩展类的属性:

val TestNet.no: Int get() = 1  //扩展成员变量

class TestNet {}

使用的时候,可以打印对象的属性了:

   val testNet = TestNet()
YYLogUtils.w("no:" + testNet.no)

扩展函数相信大家都很熟悉,我就简单的介绍一下,下面看看高阶函数。

二、高阶函数

听起来挺唬人,其实就可以理解为一个参数类型,之前Java的参数都是基本类和类型,不能把函数当参数,最多就是使用接口当参数。

Kotlin支持把函数当做参数类型,看看如何定义:

fun requestNetwork(
        onCancel: () -> Unit,   //空参和空返回值
        onFinished: ((Boolean) -> Boolean)? = null,  //带参数带返回值
        onFailed: (FailedCallback) -> Unit     //使用带参数的高阶函数的方式
    )

高阶函数在Kotlin中可以说是代替了接口的回调

    val callback: (Int, String) -> Unit = { int, str ->
        toast("int : $int ; str: $str")
    }

    //启动Fragment
    start(Demo11OneFragment2(callback))

另一边就可以通过这个callback回调给当前页面

class Demo11OneFragment2(private val _callback: ((Int, String) -> Unit)?) : BaseFragment() {

    ...

    override fun onDestroy() {
        super.onDestroy()
       //高阶函数回调
        _callback?.invoke(10, "返回给One Page的数据")
    }
}

下面我们通过一个例子来说明高阶函数与扩展函数的结合:

class TestNet {

    fun requestNetwork(
        onCancel: () -> Unit,   //空参和空返回值
        onLoading: ((isShowLoading: Boolean) -> Boolean)? = null,  //带参数带返回值
        onSuccess: SuccessCallback,
        onFailed: FailedCallback
    ) {

        MainScope().launch {
            onLoading?.invoke(true)

            val result = withContext(Dispatchers.IO) {
                delay(1500)

                return@withContext Random(10).nextLong()
            }

            when {
                result > 8 -> {
                    onCancel()
                }
                result > 5 -> {
                    onSuccess.onSuccess()
                }
                else -> {
                    onFailed.onFailed()
                }
            }
        }

    }


    interface SuccessCallback {
        fun onSuccess()
    }


    interface FailedCallback {
        fun onFailed()
    }
}

很简单的例子,模拟网络请求,通过不同的值回调不同的函数。

看看如何接收回调:

        TestNet().requestNetwork(onCancel = {

            },onFailed = object : TestNet.FailedCallback {
                override fun onFailed() {

                }
            }, onSuccess = object : TestNet.SuccessCallback {
                override fun onSuccess() {

                }
            })

这就有点不优雅了,我们的原则是能去掉object:xx 这种函数的尽量去掉。其实这种 interface 接口的方式 ,不能使用高阶函数那样直接{ } 回调,不过我们可以通过SamType的方式来优化。

三、SamType

Java8 可以在只有单一抽象方法的接口称为SAM接口或函数式接口,通过Lambda可以大大简化SAM接口的调用。

Kotlin默认是不行的,但是1.4版本之后Kotln开始支持了,看看如何使用。

    interface NetworkTrackCallback {
        fun onCallEnd(map: Map<String, Any>)
    }

可以看到使用报错的

改为Sam的方式,直接加fun

    fun interface NetworkTrackCallback {
        fun onCallEnd(map: Map<String, Any>)
    }

这样就可以直接使用了:

我们修改上面请求网络的例子:

    fun interface SuccessCallback {
        fun onSuccess()
    }


    fun interface FailedCallback {
        fun onFailed()
    }

定义的时候就能直接使用{}了。

     TestNet().requestNetwork(onCancel = {

            },onFailed = {
                toast("test network onFailed")
            }, onSuccess = {
                toast("test network onSuccess")
            })

四、高阶扩展函数

顾名思义,就是高阶函数+扩展函数的使用。之前的例子都是 onSuccess onFailed 直接回调的接口对象,我们可以通过高阶函数或高阶扩展函数的的方式定义。

直接上代码:

class TestNet {

    fun requestNetwork(
        onCancel: () -> Unit,   //空参和空返回值
        onLoading: ((isShowLoading: Boolean) -> Boolean)? = null,  //带参数带返回值
        onSuccess: SuccessCallback.() -> Unit,  //使用高阶扩展函数的方式
        onFailed: (FailedCallback) -> Unit  //使用带参数的高阶函数的方式
    ) {

        MainScope().launch {
            onLoading?.invoke(true)

            val result = withContext(Dispatchers.IO) {
                delay(1500)

                return@withContext Random().nextInt(10)
            }

            YYLogUtils.w("result:$result")

            when {
                result > 8 -> {
                    onCancel()
                }
                result > 5 -> {
                    onSuccess(SuccessCallback {
                        YYLogUtils.w("高阶扩展函数调用执行")
                    })
                }
                else -> {
                    onFailed(FailedCallback {
                        YYLogUtils.w("可以随便写点什么逻辑")
                    })
                }
            }
        }

    }

    fun interface SuccessCallback {
        fun onSuccess()
    }


    fun interface FailedCallback {
        fun onFailed()
    }
}

上面的注释已经标明,使用 SuccessCallback.() -> Unit 为高阶扩展函数。使用 (FailedCallback) -> Unit 为高阶函数。可以实现一样的效果,只是使用回调的时候,一个是it 一个是this。

并且使用高阶函数作为参数的话,就不是一个纯粹的回调了,而是二重回调。你中有我,我中有你,外面一层是我回调你,内部的函数是你回调我。

看看如何使用:

   TestNet().requestNetwork(onCancel = {

                toast("test network onCancel")

            }, onFailed = {
                //先调用内部的函数处理逻辑
                it.onFailed("哎呦")  //在这里调用内部定义过的函数,如果不调用,TestNet中 YYLogUtils.w("可以随便写点什么逻辑") 不会执行

                //在打印日志
                YYLogUtils.w("test network onFailed")

            }, onSuccess = {
                //先打印日志
                YYLogUtils.w("test network onSuccess")

                //再调用内部的函数处理逻辑
                onSuccess("我的成功数据字符串")    //上面是高阶函数的调用 - 这里是高阶扩展函数的调用,同样的效果,上面需要用it调用,这里直接this 调用
                
            }, onFinished = {
                YYLogUtils.w("当前值是10,满足条件:$it")  //这里的it是那边的回调
                true  //那边是带参数返回的,这里需要返回Booble给那边
            })

到这里就开始复杂了,不过我注释的很详细了。结合打印日志应该能看懂调用流程!

五、复杂的高阶扩展函数

上面的高阶扩展函数 SuccessCallback.() -> Unit 都是最简单的使用。如果我们加大难度,如果接口中定义的是多个函数,且带参数带返回值,又如何使用呢?

上代码:

class TestNet {

    fun requestNetwork(
        onCancel: () -> Unit,   //空参和空返回值
        onFinished: ((Boolean) -> Boolean)? = null,  //带参数带返回值
        onSuccess: SuccessCallback.() -> String,   //使用高阶扩展函数的方式
        onFailed: (FailedCallback) -> Unit     //使用带参数的高阶函数的方式
    ) {

        MainScope().launch {

            val result = withContext(Dispatchers.IO) {
                delay(1500)

                return@withContext Random().nextInt(10)
            }

            YYLogUtils.w("result:$result")

            when {
                result == 10 -> {
                    val res = onFinished?.invoke(true)

                    YYLogUtils.w("接收到对面return的值 :$res")
                }
                result > 8 -> {
                    onCancel()
                }
                result > 5 -> {
                    val res = onSuccess(object : SuccessCallback {
                        override fun onSuccess(str: String): String {
                            //这里的str是外包传进来的,我们对这个字符串做处理
                            val str2 = "$str 再加一点数据"
                            YYLogUtils.w("result:$str2")
                           return str2
                        }

                        override fun doSth() {
                            YYLogUtils.w("可以随便写点什么成功之后的逻辑")
                        }
                    })

                    YYLogUtils.w("res:$res")

                }
                else -> {
                    onFailed(object : FailedCallback {    //这种接口的方式只能使用object的实现了
                        override fun onFailed(str: String) {
                            YYLogUtils.w("可以随便写点什么Failed逻辑 :$str")
                        }

                        override fun onError() {
                            YYLogUtils.w("可以随便写点什么Error逻辑")
                        }
                    })
                }
            }
        }

    }

    interface SuccessCallback {  //多个函数不能使用fun修饰了
        fun onSuccess(str: String): String

        fun doSth()
    }


    interface FailedCallback {  
        fun onFailed(str: String)

        fun onError()
    }
}

多个函数就不能使用Sam的方式来修饰接口了,但是我们使用的是高阶函数类型,所以是可以直接使用{}的。

下面看看如何使用:

            TestNet().requestNetwork(onCancel = {

                toast("test network onCancel")

            }, onFailed = {
                //先调用内部的函数处理逻辑
                it.onFailed("哎呦")  //在这里调用内部定义过的函数,如果不调用,TestNet中 YYLogUtils.w("可以随便写点什么逻辑") 不会执行

                it.onError()

                //在打印日志
                YYLogUtils.w("test network onFailed")

            }, onSuccess = {
                //先打印日志
                YYLogUtils.w("test network onSuccess")

                //再调用内部的函数处理逻辑
                onSuccess("我的成功数据字符串")    //上面是高阶函数的调用 - 这里是高阶扩展函数的调用,同样的效果,上面需要用it调用,这里直接this 调用

                doSth()

            }, onFinished = {
                YYLogUtils.w("当前值是10,满足条件:$it")  //这里的it是那边的回调
                true  //那边是带参数返回的,这里需要返回Booble给那边
            })

和上面一样的执行顺序,同样分为两级回调,一级回调还是没变,只是多个二级回调的方法而已。

日志和上面的差不多就不贴图了。

六、Kotlin的DSL的实现

DSL本意是领域特定语言,在Kotlin中就是让接口中多个函数实现的,可以直接使用{}的定义方式。

我们通过 高阶函数+高阶扩展函数 可以同样可以实现DSL的效果。

修改代码为监听回调的方式(是不是很Java)

    interface SuccessCallback {  //多个参数不能使用fun修饰了
        fun onSuccess(str: String): String

        fun doSth()
    }

    var callback: SuccessCallback? = null

    fun setOnSuccessCallback(callback: SuccessCallback) {
        this.callback = callback
    }

很普通的Java方式定义接口与监听回调,直接使用太简单了。

       testNet.setOnSuccessCallback(object : TestNet.SuccessCallback {
                override fun onSuccess(str: String): String {
                    
                }

                override fun doSth() {
             
                }
            })

那么我们修改为DSL方式:

可以看到下面类可以理解为一个桥接层,把普通的接口函数转换为一个高阶函数。

class SuccessCallbackImpl : TestNet.SuccessCallback {

    private var onSuccess: ((String) -> String)? = null

    private var doSth: (() -> Unit)? = null

    fun onSuccess(method: (String) -> String) {
        onSuccess = method
    }

    fun doSth(method: () -> Unit) {
        doSth = method
    }

    override fun onSuccess(str: String): String {
        return onSuccess?.invoke(str).toString()
    }

    override fun doSth() {
        doSth?.invoke()
    }
}

设置新的监听方法:

可以看到这里就是使用了高阶扩展函数,事件回调给 SuccessCallbackImpl 中的 onSuccess doSth函数。

fun TestNet.setOnSuccessCallbackDsl(init: SuccessCallbackImpl.() -> Unit){
    val listener = SuccessCallbackImpl()
    init(listener)
    this.setOnSuccessCallback(listener)
}

到此我们就修改一个DSL完成了,我们试试如何使用。

我们修改TestNet类中的代码,onSuccess 的回调直接通过setOnSuccessCallback 的方法来回调。

class TestNet {

    fun requestNetwork(
        onCancel: () -> Unit,   //空参和空返回值
        onFinished: ((Boolean) -> Boolean)? = null,  //带参数带返回值
        onFailed: (FailedCallback) -> Unit     //使用带参数的高阶函数的方式
    ) {

        MainScope().launch {

            val result = withContext(Dispatchers.IO) {
                delay(1500)

                return@withContext Random().nextInt(10)
            }

            YYLogUtils.w("result:$result")

            when {
                result == 10 -> {
                    val res = onFinished?.invoke(true)

                    YYLogUtils.w("接收到对面return的值 :$res")
                }
                result > 8 -> {
                    onCancel()
                }
                result > 5 -> {

                   val res =  callback?.onSuccess("success")

                    YYLogUtils.w("res:$res")

                    callback?.doSth()

                }
                else -> {
                    onFailed(object : FailedCallback {    //这种接口的方式只能使用object的实现了
                        override fun onFailed(str: String) {
                            YYLogUtils.w("可以随便写点什么Failed逻辑 :$str")
                        }

                        override fun onError() {
                            YYLogUtils.w("可以随便写点什么Error逻辑")
                        }
                    })
                }
            }
        }

    }

    interface SuccessCallback { 
        fun onSuccess(str: String): String

        fun doSth()
    }

    interface FailedCallback {  
        fun onFailed(str: String)

        fun onError()
    }

    var callback: SuccessCallback? = null

    fun setOnSuccessCallback(callback: SuccessCallback) {
        this.callback = callback
    }
}

使用:

 testNet.setOnSuccessCallbackDsl {
        onSuccess { str ->
            YYLogUtils.w("str: $str")
                str + "再加一点数据"
            }
        doSth {
                YYLogUtils.w("可以随便写点什么成功之后的逻辑")
            }
    }

以上就完成了一个DSL的改装,完美运行,当然这是接口有多个实现函数可以这么搞,如果接口只有一个函数我们可以选择直接使用高阶函数,或者使用SamType的方式定义都可以,完全就不需要这么麻烦的定义DSL了。

总结

我们从一个案例中,完成了从 扩展函数-> 高阶函数-> Sam -> 高阶扩展函数 -> DSL 等多种方案的演变。其实他们一个点都可以深挖去单独出一篇文章,这里我就不深挖了,只是演示基本的使用而已。

可以看到其实高阶函数才是这些功能的基石,也是相比Java代码更方便的一个点,大家使用的时候一定要掌握的就是高阶函数这个点。

其实每一种定义方法都能实现对应的效果,各有各有的好处。我们自己写逻辑随意就好,但是我们要看懂别人这么写的逻辑是什么,不然别人写的代码你弄不清执行顺序,逻辑都看不懂了。我们看很多框架的源码实现,或者看别人的代码逻辑。就算我们不认可,不习惯这些定义方式,但是我们至少能理解代码的调用逻辑与顺序。看懂代码逻辑。

一句话解释就是,我可以不用,但是我不能没有,我自己不这么写,但你这么写我能懂!

Ok,最后还是老样子,如有错漏请指出,如果有其他更好的方式,欢迎交流!

好了,今天就到这里了,天天这么更新扛不住了。

完结!

分类:
Android
标签:
分类:
Android
标签:
收藏成功!
已添加到「」, 点击更改