Android kotlin高阶函数与Java lambda表达式介绍与实战

一、介绍

        目前在Java JDK版本的不断升高，新的表达式已开始出现，但是在Android混淆开发中，kotlin的语言与Java的语言是紧密贴合的。所以Java lambda表达式在kotlin中以新的身份出现：高阶函数与lambda表达式特别类似。接下来我讲会先讲Java的lambda，再介绍kotlin的高阶函数。

二、Java lambda表达式介绍与实战

2.1lambda的表达式格式介绍

 1. 不需要参数,返回值为 5  
() -> 5  
  
 2. 接收一个参数(数字类型),返回其2倍的值  
x -> 2 * x  
  
 3. 接受2个参数(数字),并返回他们的差值  
(x, y) -> x – y  
  
 4. 接收2个int型整数,返回他们的和  
(int x, int y) -> x + y  
  
5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)  
(String s) -> System.out.print(s)

大致可以分为几类：

1.有参数无返回值(String msg)->

2.无参数有返回值()->Int

3.有参数有返回值(int a,int b)->()

2.2实战

        Java lambda表达式是通过接口定义出来，一个接口只能定义一种类型，具体逻辑需要通过Java lambda自行定义，接口只想当一种类型

interface Add {
    int add(int a, int b); //返回值
}

上面定义了一个Add类型，

Add add = (int a, int b) -> (a + b);//什么+
Add sub = (int a, int b) -> (a - b);//申明-
Add mul = (int a, int b) -> (a * b);//申明

通过Add类型定义了三种lambda操作符。这样就完成了

使用

1.第一种通过操作符类型自行执行

public int operation(int a, int b, Add add) {
    return add.add(a, b);
}

2.直接调用

add.add(10, 20)

2.3实战Demo

public class TestJava {


    @Test
    public void main() {
        TestJava tester = new TestJava();


        Back back = () -> 4;

        Log log = (String msg) -> com.example.lib.Log.INSTANCE.log(msg);
        //单个形参，可以不用注明变量类型
        Log log1 = msg -> com.example.lib.Log.INSTANCE.log(msg);

        Add add = (int a, int b) -> (a + b);//什么+
        Add sub = (int a, int b) -> (a - b);//申明-
        Add mul = (int a, int b) -> (a * b);//申明


        com.example.lib.Log.INSTANCE.log("back=" + back);
        log.log("我调用了Log");
        com.example.lib.Log.INSTANCE.log("add=" + add.add(10, 20));
        tester.operation(50, 10,add);
        tester.operation(50, 10,sub);


    }






    public int operation(int a, int b, Add add) {
        return add.add(a, b);
    }

    interface Back {

        int back(); //返回固定参数

    }

    interface Add {
        int add(int a, int b); //返回值


    }

    interface Log {
        void log(String msg);
    }
}

三、kotlin的高阶函数定义与使用

        通过Java的lambda的表达式学习，已掌握了表达式的使用。在kotlin中，把lambda的表达式定义为高阶函数。用法差不多

在kotlin中，高阶函数的定义：

格式：函数名(形参类型...)->返回值

例如：add(Int ,Int)->Int,log(String)->Unit

形参只需要申明参数类型，可以支持多个或者为空。返回值，如果不需要直接些Unit

使用教程

kotlin的高阶函数与Java的lambda表达式很相似，但是用法不同，高阶函数是用在函数中的，作为参数使用。类似与接口回调。

实战：

1.定义一个加法

 fun add(a: Int, b: Int, log: (Int, Int) -> Int) {

        val data = log(a, b)
        Log.log(data)

    }

2.调用

    test.add(2, 3, { a, b ->
        Log.log("a + b=${a + b}")
        a + b
    })

    test.add(2, 4) { a, b ->

        a + b
    }

正常调用有两种：

1.参数在方法体中(2,3,{a,b->})

2.方法外(2,4){a,b->}

注意：如果有返回值，最后一行表达式或者参数将作为函数变量返回，无需用return

引用调用两种:

1.在函数体定义一个函数与方法中的参数函数一样，实现这个函数的方法体

    fun addNum(a: Int, b: Int): Int {

        return a + b

    }

调用：

用当前函数变量引用这个方法即可

   val addNum3 = test.add(1, 2, test::addNum)

2.在函数体外定义一个方法,kotlin支持在函数体外定义函数，这个函数类似全局函数，只是调用只需指向函数名，不需要当前类。

    val addNum2 = test.add(1, 2, ::addNum)

Demo：

class Test {


    fun add(a: Int, b: Int, log: (Int, Int) -> Int) {

        val data = log(a, b)
        Log.log(data)

    }

    fun log(msg: String, show: (String) -> Unit) {
        show(msg)
    }

    fun addNum(a: Int, b: Int): Int {

        return a + b

    }

}

fun main() {
    val test = Test()
    test.add(2, 3, { a, b ->
        Log.log("a + b=${a + b}")
        a + b
    })

    test.add(2, 4) { a, b ->

        a + b
    }



    test.log("msg") {

        Log.log(it)

    }

    val addNum2 = test.add(1, 2, ::addNum)
    Log.log("addNum2=${addNum2}")

    val addNum3 = test.add(1, 2, test::addNum)
    Log.log("addNum3=${addNum3}")
}

// ::addNum 这是一种函数引用的写法，表示将函数addNum()来作为参数传递给高阶函数
fun addNum(a: Int, b: Int): Int {

    return a + b

}

四、总结

        kotlin的写法是比较特殊，高阶函数类似接口返回，Java中的lambda的表达式，更像一个定义语言。但是语法接口类似，只是在使用上有所区别。

        特别是kotlin，在大趋势kotlin的写法中，高阶函数使用特别多，甚至一些开发者把高阶当成接口回调。新手特别注意。