前言

上一篇罗列过Kotlin的属性与函数的基本知识，算是入门篇本。本篇将继续对函数的一些高级用法进行深入分析。
通过本篇，你将了解到：

1、什么是函数类型？
2、Kotlin 函数类型形参声明/实参定义
3、Kotlin 函数类型参数调用
4、匿名函数与Lambda
5、Kotlin 函数作为返回值
6、Java 如何调用Kotlin 函数？

1、什么是函数类型？

Java 如何传递方法？

有个场景：

输入学生的姓名、年龄，返回该学生的考试分数。

通常我们会将它封装为一个方法，而方法需要放在类或者接口里，最终调用时是通过类/接口的实例化对象调用该方法，如下：

    private void testStudent(HandleStudent handleStudent) {
        float score = 0;
        if (handleStudent != null) {
            score = handleStudent.getScore("fish", 18);
        }
        System.out.println("score:" + score);
    }
    //接口
    interface HandleStudent {
        //传入学生的姓名、年龄，返回学生的分数
        float getScore(String name, int age);
    }

实际上我们只需要调用getScore(xx)方法，为了实现这个目的，需要将它放到类/接口封装，最后生成实例对象调用，多了好几个步骤。
有没有更简单的方式呢？比如直接传递方法本身？
答案是：没有。

因为在Java 的世界里，类/接口 是一等公民，方法必须依赖于它们存在。

Kotlin 函数类型

Java 不支持方法作为方法的参数，而Kotlin 却支持函数作为函数的参数/返回值。

因为在Kotlin 的世界里，函数是一等公民，可以脱离类/接口而存在。

如果你接触过C++等语言，相信你对函数参数不会太陌生，C++里有函数指针，指向的是一个函数的指针，通过该指针就可以调用其指向的函数。

还是以获取学生分数为例：

fun upFun1(name: String, age: Int): Float {
    return 88f
}

我们只关注该函数的输入参数与返回值，并不关心该函数的名字，而函数的输入参数与返回值就决定了该函数的类型。
upFun1 的函数类型为：

(String, Int)->Float 输入参数类型为：String 和 Int，多个参数之间用","隔开，所有参数使用()括起来 返回值类型为：Float，返回值与输入参数之间使用"->"连接。

如此一来就可以表示一个函数的类型。

2、Kotlin 函数类型形参声明/实参定义

形参声明

在上一篇文章里，我们有提到过：Kotlin里的引用类型包括函数这种引用类型，既然是引用，那么当然可以作为参数传递了，来看看如何声明一个使用了函数作为形参的函数。

//testUpFun1 接收的参数为函数类型：(String, Int)->Float
fun testUpFun1(getScore : (String, Int)->Float) {
}

传入的形参不使用的话没啥意义，对于函数类型，通常是调用该函数，如下：

//testUpFun1 接收的参数为函数类型：(String, Int)->String
fun testUpFun1(getScore : (String, Int)->Float) {
    var score = getScore("fish", 18)
    println("student score:$score")
}

实参定义

形参有了，当调用testUpFun1(xx)时需要传入实参，也就是传入函数的定义：

fun upFun1(name: String, age: Int): Float {
    return 88f
}

定义了upFun1函数，该函数类型为：(String, Int)->Float，符合作为testUpFun1 形参的条件。

3、Kotlin 函数类型参数调用

形参和实参都有了，接着来看如何将两者结合起来，总结来说有如下几种方式：

接下来一一看看三者的实现方式。

函数引用

当我们定义了一个函数后，想将这个函数作为实参传递给另一个函数，可以通过:: + 函数名 的方式传递，官方说法叫做：函数引用。

fun upFun1(name: String, age: Int): Float {
    return 88f
}

//testUpFun1 接收的参数为函数类型：(String, Int)->String
fun testUpFun1(getScore : (String, Int)->Float) {
    var score = getScore("fish", 18)
    println("student score:$score")
}

fun main(args: Array<String>) {
    //通过函数引用调用
    testUpFun1(::upFun1)
}

如上，testUpFun1 函数需要传入一个函数类型的参数，通过"::"引用函数名即可。

变量（函数类型）

普通函数定义

既然函数引用可以当做参数传递，那么它当然可以赋值给变量，如下：

fun upFun1(name: String, age: Int): Float {
    return 88f
}
//赋值
//var varFun:(String, Int)->Float = ::upFun1
//类型推断，可以不用写变量类型
var varFun = ::upFun1

fun main(args: Array<String>) {
    testUpFun1(varFun)
}

此时，我们只需要把varFun 作为实参传递即可。
需要注意的是：Kotlin 会对变量进行类型推断，因此我们可以省略变量类型

匿名函数

当然了，若是想要在声明变量的同时将函数定义了，这也是可以的：

//匿名函数
//var varFun1:(String, Int)->Float = fun (name: String, age: Int):Float {
//    return 88f
//}
//类型推断
var varFun1 = fun (name: String, age: Int):Float {
    return 88f
}
fun main(args: Array<String>) {
    testUpFun1(varFun1)
}

可以看出，我们声明的函数没有函数名，只有一个"fun"声明。
此时，varFun1 表示的是一个匿名函数。
同样的因为类型自动推导，可以不用写变量类型。

Lambda 表达式

在Java 里，有时候我们会将匿名内部类转为Lambda形式，而Kotlin 对于Lambda的使用更广泛了，上面的匿名函数我们可以用Lambda表示。

//Lambda 表达式
//var lambda1:(String, Int)->Float = {
//    name:String,age:Int->
//    88f
//}
//类型推导
var lambda1 = { name: String, age: Int ->
    88f
}
fun main(args: Array<String>) {
    testUpFun1(lambda1)
}

可以看出，变量作为实参传递，对比普通函数定义、匿名函数、Lambda 表达式三者写法，发现Lambda最简洁，简洁有时候也意味着难以理解。

Lambda 格式以及一些风骚写法，我们放在下节分析

直接传入函数体

不管是函数引用还是变量作为实参，都需要先将函数定义好，有时候函数只在一个地方使用，无需再单独定义出来，此时可以选择直接将函数体当做实参传递。

匿名函数

在调用函数的时候，直接传入匿名函数作实参：

//testUpFun1 接收的参数为函数类型：(String, Int)->String
fun testUpFun1(getScore: (String, Int) -> Float) {
    var score = getScore("fish", 18)
    println("student score:$score")
}

fun main(args: Array<String>) {
    //传入匿名函数
    testUpFun1(fun(name: String, age: Int): Float {
        return 88f
    })
}

Lambda

老样子，一般匿名函数都可以用Lambda 替代：

fun main(args: Array<String>) {
    //Lambda 表示
    testUpFun1({ name: String, age: Int ->
        88f
    }
    )
}

此时，编译器会提示你可以再优化一下写法：

fun main(args: Array<String>) {
    //传入匿名函数
    testUpFun1 { name: String, age: Int ->
        88f
    }
}

我们知道函数的调用需要用"()"括起来，此时"()"都没了，越来越简洁了。

4、匿名函数与Lambda

上面简单展示了匿名函数和Lambda的使用，只是一些基本写法，尤其是Lambda还有一些风骚写法，接着来分析。

匿名函数

顾名思义，函数是有函数名的，如果省略了函数名那么就称之为匿名函数。

//定义匿名函数
var anoymous1: (String, Int) -> Float = fun(name: String, age: Int): Float {
    println("name:$name age:$age")
    return 88f
}
//自动推导，消除变量类型
var anoymous2 = fun(name: String, age: Int): Float {
    println("name:$name age:$age")
    return 88f
}

//调用
fun main(args: Array<String>) {
    //传入匿名函数
    testUpFun1(fun(name: String, age: Int): Float {
        println("name:$name age:$age")
        return 88f
    })
    testUpFun1(anoymous1)
    testUpFun1(anoymous2)
}

需要注意的是：

匿名函数返回值表示的是该匿名函数本身的返回值。

Lambda

匿名函数还是不够简洁，此时Lambda出现了，分三步阐述。

Lambda 基本结构

var varLambda2 = { name: String, int: Int ->
    println()
    test()
    "jj"
}

以此为例，Lambda 有如下约定：

1、大括号"{}" 包裹内容。
2、使用"->"连接参数与实现体。
3、"->"左边表示参数列表，参数间使用","分割。
4、"->"右边表示实现体，多个语句分行表示。
5、如果没有参数列表，那么"->"可以省略。
6、Lambda 无需"return"关键字，最后一行默认表示返回值（如例子中"jj"表示Lambda返回了String类型。

变量接收Lambda

//完整写法
var varLambda1:(String, Int)->Float = { name: String, age: Int ->
    println("student name:$name age:$age")
    88f
}

因为自动推导类型，因此可以省略变量类型：

//省略类型
var varLambda1 = { name: String, age: Int ->
    println("student name:$name age:$age")
    88f
}

当然，非得要类型的话，还可以这么写：

//Lambda里省略了参数类型，因为"="之前已经声明了
var varLambda1: (String, Int) -> Float = { name, age ->
    println("student name:$name age:$age")
    88f
}

函数调用传入Lambda

接下来通过不同的case由浅入深演示Lambda各种风骚写法。

第一种Case：
将之前的testUpFun1 改造一下，新增一个参数，如下：

//testUpFun1 接收的参数为函数类型：(String, Int)->String
fun testUpFun1(getScore: (String, Int) -> Float) {
    var score = getScore("fish", 18)
    println("student score:$score")
}

//改造后
fun testUpFun2(getScore: (String, Int) -> Float, needDelay:Boolean) {
    if (needDelay)
        println("delay...")
    var score = getScore("fish", 18)
    println("student score:$score")
}

testUpFun2 函数有两个参数，一个是函数类型，另一个是Boolean。
接着来看看如何调用testUpFun2 函数，我们以直接传入函数体为例：

fun main2(args : Array<String>) {
    testUpFun2({ name: String, age: Int ->
        println("name:$name age:$age")
        88f
    }, true
    )
}

第二种Case:
我们再变一下testUpFun2 参数，函数类型和Boolean交换位置：

fun testUpFun3( needDelay: Boolean, getScore: (String, Int) -> Float) {
    if (needDelay)
        println("delay...")
    var score = getScore("fish", 18)
    println("student score:$score")
}

调用如下：

fun main3(args: Array<String>) {
    testUpFun3(true, { name: String, age: Int ->
        println("name:$name age:$age")
        88f
    }
    )
}

此时，编译器会提示你可以将"{}"整体提取出来放在"()"括号后，如下：

fun main3(args: Array<String>) {
    testUpFun3(true
    ) { name: String, age: Int ->
        println("name:$name age:$age")
        88f
    }
}

这是Lambda的一个约定：

如果Lambda 作为函数的最后一个参数，那么Lambda可以提取到"()"外展示。

第三种Case:
再对testUpFun3 参数做调整，只保留一个函数类型的参数：

//定义
fun testUpFun4(getScore: (String, Int) -> Float) {
    var score = getScore("fish", 18)
    println("student score:$score")
}
//调用
fun main4(args: Array<String>) {
    testUpFun4(
    ) { name: String, age: Int ->
        println("name:$name age:$age")
        88f
    }
}

同样的编译器会提示可以将"()"省略，如下：

fun main4(args: Array<String>) {
    //省略"()"
    testUpFun4 { name: String, age: Int ->
        println("name:$name age:$age")
        88f
    }
}

这是Lambda的一个约定：

如果Lambda 作为函数的唯一参数，那么调用函数"()"可以省略。

第四种Case:
这次不修改testUpFunX，我们修改Lambda表达式的入参，改为：

//单参数
fun testUpFun5(getScore: (String) -> Float) {
    var score = getScore("fish")
    println("student score:$score")
}
调用如下:
fun main5(args: Array<String>) {
    ////省略"()"
    testUpFun5  { name: String ->
        println("name:$name")
        88f
    }
}

此时，可以写成如下方式：

fun main5(args: Array<String>) {
    ////省略"()"
    testUpFun5  {
        //用it 替代了Lambda 的name
        println("name:$it")
        88f
    }
}

这是Lambda的一个约定：

如果Lambda 入参只有一个，那么可以省略"->"以及入参列表，并在实现体里用it 指代这个唯一的参数。

第五种Case:
Lambda 有1个入参可以用"it"指代，Lambda 没有入参呢？

//无参数
fun testUpFun6(getScore: () -> Float) {
    var score = getScore()
    println("student score:$score")
}
fun main6(args: Array<String>) {
    ////省略"()"
    testUpFun6 {
        println("name")
        88f
    }
}

可以看出，此时只需要"{}"括起来即可。
这是Lambda的一个约定：

如果Lambda 没有入参，那么可以省略"->"以及入参列表。

注：此时在Lambda里不能使用"it"，因为它根本没入参。

以上就是Kotlin Lambda 常用的一些变换规则。

5、Kotlin 函数作为返回值

定义函数：

fun testUpFun7(getScore: (String) -> Unit): (Boolean, Int) -> String {
    //调用函数
    var score = getScore("fish")
    println("student score:$score")

    //返回函数，Lambda表示
    return { need: Boolean, age: Int ->
        println("need:$need  age:$age")
        "fish"
    }
}

调用：

fun main7(args: Array<String>) {
    ////省略"()"
    var testReturn = testUpFun7 {
        println("name:$it")
    }
    //调用
    testReturn(true, 5)
}

只要掌握了高阶函数的传参，返回值也不在话下，此处就不展开细说了。

6、Java 如何调用Kotlin 函数？

以上都是Kotlin 调用 Kotlin，来看Java 如何调用Kotlin的高阶函数。
还是以如下函数为例：

fun testUpFun3(needDelay: Boolean, getScore: (String, Int) -> Float) {
    if (needDelay)
        println("delay...")
    var score = getScore("fish", 18)
    println("student score:$score")
}

在Java里调用：

    private void testKotlin() {
        UpFunKt.testUpFun3(true, new Function2<String, Integer, Float>() {
            @Override
            public Float invoke(String s, Integer integer) {
                return null;
            }
        });
    }

可以看出testUpFun3里的函数类型参数转化为了Function2 的实例，Function2 为何方神圣？

实际上就是Kotlin 里为了兼容Java 调用定义了一堆接口，这些接口标明了入参和返回值，Java 调用时需要重写invoke()方法即可，当在Kotlin里调用对应的函数参数时，将会调用到invoke()回到Java 代码。
在Functions.kt里定义了23个接口：

基本上可以满足大部分的参数需求。

小结 理解了以上内容，我相信大家对Lambda各种写法都不会再陌生，如果你还是有疑惑，可能是我没阐述明白，欢迎留言讨论。
下篇将会继续分析泛型函数、扩展函数、内联函数、常用的高阶函数如let/run/apply 等，进而自然过渡到协程的分析，那时再看协程就事半功倍了。

本文基于Kotlin 1.5.3，文中Demo请点击