习惯使用kotlin高阶函数

kotlin提供了高阶函数这个概念，能够在一些场景提升编码效率

1、什么是高阶函数

通俗的说和数学里面的高阶函数概念相似，也就是函数里面的参数能够是函数。固然返回值也能够是函数。

2、kotlin高阶函数使用场景分析

1.先看看平时使用比较多的内置高阶函数 用kotlin写view的onClickListener

tV.setOnClickListener {
            //doSomeThing
        }
复制代码

里面的lamba表达式就是一个函数

不太形象？再看看集合里面的filter、map

listOf(1, 2, 3)
            .filter { it > 2 }
            .map { it + 5 }

/**
 * Returns a list containing only elements matching the given [predicate].
 */
public inline fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T> {
    return filterTo(ArrayList<T>(), predicate)
}
复制代码

filter、map的参数都是一个lambda函数

2.高阶函数有什么用

就拿filter函数来讲，好比实现一个过滤的逻辑，判断是符合的 若classA 和classB都须要调用这个函数，那么函数就须要兼容这两种状况

fun filter(): Boolean {
        if (classA) {
            return true
        } else if (classB) {
            return false
        }
        return false
    }
复制代码

if else无可厚非，可是若是后面有classC classD...都须要考虑呢，这显然违背了开闭原则。那么天然是要面向抽象而不是具体，固然就是抽象类或者接口。

若用java的方式去实现,会变成这样

interface IJudge {
        fun canFilter(): Boolean
    }

    class ClassA : IJudge {
        override fun canFilter(): Boolean {
            return true
        }
    }

    class ClassB : IJudge {
        override fun canFilter(): Boolean {
            return false
        }
    }

  fun filter(a:Int,b:Int,jugde: IJudge): Boolean {
        //加一些逻辑
        return jugde.canFilter()
    }
复制代码

这个是硬伤，面向抽象就得加这么接口，而后多写一些代码。

若用高阶函数实现

fun filter(a: Int, b: Int, canFilter: (a:Int,b:Int) -> Boolean): Boolean {
        //加一些逻辑
        return canFilter(a,b)
    }
      //调用方1
       filter(1, 2) { a: Int, b: Int ->
            a * b > 10
        }
      //调用方2
        filter(1, 2) { a: Int, b: Int ->
            a + b < 5
        }
复制代码

这样就省了个接口，后面分析实际是编译器帮忙处理，其实仍是生成了接口

3、kotlin高阶函数的实现

来看看kotlin编译器是怎么实现的吧 首先把上面那段kotlin代码反编译成java

kt:
   fun filter(a: Int, b: Int, canFilter: (a:Int,b:Int) -> Boolean): Boolean {
        //加一些逻辑
        return canFilter(a,b)
    }
java:
 public final boolean filter(int a, int b, @NotNull Function2 canFilter) {
      Intrinsics.checkParameterIsNotNull(canFilter, "canFilter");
      canFilter.invoke(a, b);
      return (Boolean)canFilter.invoke(a, b);
   }
复制代码

其实是kt内置的 Functions.kt

这里因为我传的是2个参数的lambda函数，因此调用的是Function2

那么从这里能得来上面结论：

a.高阶函数所谓的能够省略接口，其实只能省略只有一个方法的接口，由于function函数只有一个方法

b.上边的fliter函数除了canFIlter(a,b)还能够使用canFilter.invoke(a,b)调用。这个在须要对函数判空的时候颇有用。好比替换只有一个方法的接口回调能够callback?.invoke(a,b,c) ， 由于callbck?(a,b,c)是不能编译经过的。

c.虽然Functions.kt文件方法数是有限的，感受意味着lambda参数是有限的，最多22个参数，超过会编译失败。可是当真的超过期，会调用另一个FunctionN.kt

operator fun invoke(vararg args: Any?): R
复制代码

不过若是谁写的函数，直接传参20多个还不封成对象或者builder，怕是腿都要被打断.......

4、关于高阶函数替换接口的讨论

上面已经讨论了，当接口只有一个方法时，确实能够用高阶函数代替，省略一个接口。

可是当接口有多个方法时，显然不能直接替换。虽然也能够把几个函数包装在一块儿使用，可是仍是感受画蛇添足。

多人并行开发的时候，好比一我的负责写一个负责ui，一个负责使用ui处理业务逻辑。先把接口定好，接口方法文档写好，一目了然。这一方面仍是接口好不少，当只有简单的一个方法时，用高阶函数要方便一些。