1、Kotlin匿名函数

// TODO 匿名函数 的类型推断
fun main() {

    //匿名函数 ，类型推断为String
    //: 方式必须指定参数类型和返回类型
    //方法名 = 类型推断返回类型
//    val method : () ->={}

    //推断为String类型返回值
    val method1 = { v1: Double, v2: Float, v3: Int ->
        "v1:$v1,v2:$v2,v3:$v3"

    }

    println(method1(454.5, 351.3f, 99))
    
    val method2 = {
        32421.4f
    }

    //返回类型== Unit
    println(method2())


    val method3 = { number: Int ->
        number
    }
    //(函数):Int ->Int 返回值int 类型
    println(method3(9))
}

需要注意的是函数带()必须指定返回类型

2、Kotlin 函数隐式返回

// TODO 隐式返回
fun main() {

    //第一步 函数输入输出的声明 （）输入 ->输出 这个是声明
    val methodAction: () -> String

    //第二步，对下面函数的实现
    methodAction = {
        val input = 9999
        "$input test1"
        //匿名函数不写return ,最后一行就是返回值
    }
    println(methodAction)
}


//外面的写法与上面的methodAction等价
fun methodAction() :String{
    return "zhangsan"
}

上面可以看到，写在外面的函数可以优化为内部隐式返回

3、Kotlin中的it关键字

// TODO it 关键字
fun main() {

    val methodAction: (Int, Int, Int) -> String = { number1, number2, number3 ->
        val input = 9999
        "$input test1 参数1: $number1,参数二: $number2,参数三:$number3"
        //匿名函数不写return ,最后一行就是返回值

    }
    println(methodAction(1, 2, 3))
    println(methodAction.invoke(1, 2, 3))

    //一个参数自带it，可以省略 it 就相当于是传递进来的参数
    val methodAction2: (String) -> String = { "$it" }
    println(methodAction2("aaa"))

    val methodAction3: (Double) -> String = { "$it test" }
    println(methodAction3(11212.3))

}

//fun methodAction2(it : String) :String {return "$it test"}

Kotlin中匿名参数就一个时，it关键字就省略，其中methodAction2在内部隐式返回相当于外部的写法

4、Kotlin 中lamada

// TODO lamda表达式
fun main() {

    //(Int,Int)->String 匿名函数等价于lamda
    val addResultMethod = { number1: Int, number2: Int ->
        "两数相加的结果是:${number1 + number2}"
    }
    println(addResultMethod(1, 1))

    // lamda 表达式Int lamda 表达式结果 Any
    val weekResultMethod = { number: Int ->
        when (number) {
            1 -> "星期一"
            2 -> "星期二"
            3 -> "星期三"
            4 -> "星期四"
            5 -> "星期五"
            else -> -1
        } //(Int) ->Any

    }

}

匿名函数就相当于是lamda,一个参数时，it关键字被省略

5、Kotlin函数中参数是函数的定义

// TODO 函数中定义参数是函数的函数

const val USER_NAME_SAVE_DB = "test"
const val USER_PWD_SAVE_DB = "123456"
fun main() {

//第一种方式
    loginAPI("Derry", "123456", { msg: String, code: Int ->
        println("登录情况:msg:$msg,code:$code")
    })


//第二种方式
    loginAPI("test", "123456", responseResult = { msg: String, code: Int ->
        println("登录情况:msg:$msg,code:$code")

    })

    // 返回结果不需要走回调接口，lamda就可以表达
    loginAPI("test", "123456") { msg: String, code: Int ->
        println("登录情况:msg:$msg,code:$code")

    }

}

// java 匿名接口回调Kotlin函数作为参数回调
public fun loginAPI(username: String, userpwd: String, responseResult: (String, Int) -> Unit) {
    if (username == null || userpwd == null) {

    }

    if (username.length > 3 && userpwd.length > 3) {
        if (webServiceLoginAPI(username, userpwd)) {
            //做操作
            responseResult("login Success", 200)
        } else {
            responseResult("login error", 400)
        }
    }
}

public fun webServiceLoginAPI(name: String, pwd: String): Boolean {
    if (name == USER_NAME_SAVE_DB && pwd == USER_PWD_SAVE_DB) {
        return true
    } else {
        return false
    }
}

上面可以看到，函数中的参数带有函数，在mian中实现了三种写法

6、Kotlin 之函数内联 inline

此处编译class使用的是上面的登录逻辑代码编译，看一下没有添加内联标记的匿名函数。 注意:内联函数必须在有匿名函数的方法里进行修饰

上面代码不使用内联，编译为class之后，会生成Funtion,导致性能损耗

有lamda的方法加上内联之后，就不会造成性能损耗，没有使用lamda不需要内联函数

// java 匿名接口回调Kotlin函数作为参数回调，inline改为内联函数
public inline fun loginAPI(username: String, userpwd: String, responseResult: (String, Int) -> Unit) {
    if (username == null || userpwd == null) {

    }

    if (username.length > 3 && userpwd.length > 3) {
        if (webServiceLoginAPI(username, userpwd)) {
            //做操作
            responseResult("login Success", 200)
        } else {
            responseResult("login error", 400)
        }
    }
}

看下编译的class文件

可以看到变量都在main生成，这种就不消耗性能

7、Kotlin中的函数引用::

函数引用就是将普通函数作为函数的参数的类型引用,加::

// TODO 函数引用::

const val USER_NAME_SAVE_DB = "test"
const val USER_PWD_SAVE_DB = "123456"
fun main() {

    //lamda属于函数类型对象，把methodResponseResult 普通函数变成函数类型的引用::
    loginAPI("test", "123456", ::methodResponseResult)

    //可以单独抽出来
    val obj = ::methodResponseResult
    loginAPI("test", "123456", obj)
}

fun methodResponseResult(msg: String, code: Int) {
    println("最终的登录成果是:msg$msg,code:$code")
}


// java 匿名接口回调Kotlin函数作为参数回调
//函数有lamda应该使用内联 相当于C++  #define
public inline fun loginAPI(username: String, userpwd: String, responseResult: (String, Int) -> Unit) {
    if (USER_NAME_SAVE_DB == username && USER_PWD_SAVE_DB == userpwd) {
        responseResult("登录成功", 200)
    } else {
        responseResult("登录失败", 200)
    }
}

8、Kotlin函数类型作为返回类型

一个函数，返回String ,Double，再返回一个函数类型(java无法做到)

// TODO 函数类型作为返回类型

fun main() {
    show("学习Kotlin语言")

    //得到匿名函数后，还可以直接调用
    val method = showMethod("show")

    println(method("test", 27))

}

//返回一个boolean
fun show(info: String): Boolean {
    println("我是show函数 info:$info")
    return true
}

//返回一个String类型
fun show2(info: String): String {
    println("我是show2函数 info:$info")
    return "DDD"
}


//函数返回一个匿名函数
fun showMethod(info: String): (String, Int) -> String {
    println("我是show函数 info:$info")

    //return 一个匿名函数
    return { name: String, age: Int ->
        "我就是匿名函数，name:$name,age:$age"

    }
}

9、Kotlin的匿名函数与具名函数

匿名函数与具名函数区别就是调用一个函数后，返回的函数，可以是匿名，可以有具体名字

// TODO 函数类型作为返回类型

fun main() {

    //匿名函数, it默认省略，是一个参数使用，多个参数需要标记出
    showPersonInfo("lisi", 99, '男', "学习kotlin函数") {
        println("显示结果:$it")
    }
    /*
    showPersonInfo("lisi", 99, '男', "学习kotlin函数") {num,age->
        println("显示结果:$it")
    }
    */

    //具名函数，有具体名字的函数
    showPersonInfo("zhangsan", 26, '男', "学习C++语言", ::showResultImpl)
}

fun showResultImpl(result: String) {
    println("显示结果:$result")
}


inline fun showPersonInfo(name: String, age: Int, sex: Char, study: String, showResult: (String) -> Unit) {
    val str = "name:$name,age:$age,sex:$sex,study:$study"
    showResult(str)
}

Kotlin基础篇三之字符串与内置函数 juejin.cn/post/709984…