Kotlin基本用法(二)

package com.wzx.kotlin

/**
 * @Description TODO
 * @Author wuzhixiao
 * @Date 2023/01/10
 */
fun main() {
    //TODO  匿名函数
    val len = "wzx".count()
    println(len) //3

    val len2 = "wzx".count() {
        it == 'z'//1
    }
    val len3 = "wzx".count {
        //it 是wzx的每一个字符
        it == 'z'//1
    }
    //TODO  函数类型&隐式返回
    //写函数：第一步：函数输入输出的声明； methodAction是函数名，()是输入，String输出
    val methodAction: () -> String

    //第二步 对上面函数对实现 最后一行为return的东西
    methodAction = {
        val inputValue = 123
        "$inputValue wzx"
        //匿名函数不用写return，最后一行就是返回值
    }

    //第三步 调用函数
    methodAction()

    //TODO  函数参数
    //写函数：第一步：函数输入输出的声明 第二步 对上面函数对实现
    val methodAction2: (Int, Int, Int) -> String = { number1, number2, number3 ->
        val inputValue2 = 123
        "$inputValue2  wzx $number1,$number1,$number1"//最后一行 默认是返回值
    }
    //第三步 调用函数
    methodAction2(1, 2, 3)

    //TODO it关键字
    val methodAction3: (Int, Int, Int) -> String = { number1, number2, number3 ->
        val inputValue2 = 123
        "$inputValue2  wzx $number1,$number1,$number1"//最后一行 默认是返回值
    }
    methodAction2.invoke(1, 2, 3) // 等价于 methodAction2(1,2,3)

    //传入参数为1个时 参数名自动为it
    val methodAction4: (String) -> String = { "$it wzx" }
    println(methodAction4("www"))

    val methodAction5: (Double) -> String = { "$it wzx2" }
    println(methodAction5(11.2))

    //TODO 匿名函数的类型推断
    //匿名函数，类型推断为String
    //"方法名 : " ，带冒号，必须指定参数类型和返回类型
    val methodAction6: (Int) -> String = { "" }
    //"方法名="，带等号，类型推断返回值
    val methodAction7 = { v1: Double, v2: Float, v3: Int ->
        "v1：$v1,v2：$v2,v1：$v3" //自动推断出返回值类型
    }
    methodAction7(11.1, 12.1f, 1)

    val method2 = {
        1.1f
    }//() -> Unit
    method2()

    val method3 = { number: Int ->
        number
    }//(Int) -> Int
    method3(1)


    //TODO Lamda
    //匿名函数 == Lamda表达式
    val addResulitMethod = { number1: Int, number2: Int ->
        "两数相加的结果：${number1 + number2}"
    }
    addResulitMethod(1, 1)

    //匿名函数 入参Int，返回Any类型
    //lambda表达式的入参为Int，lambda表达式的结果Any类型
    val weekResultMethod = { number: Int ->
        when (number) {
            1 -> "星期一"
            2 -> "星期二"
            else -> -1
        }
    } //这个函数的返回值类型为Any
    println(weekResultMethod(2))

    //总结 匿名函数 属于 lambda

    //TODO 在函数中定义参数是函数的函数
    //先看函数，再看这里的调用
    login("wzx", "123") { msg: String, code: Int ->
        println("最终登录情况：msg:$msg code:$code")
    }
    //TODO 在函数中定义参数是函数的函数 调用的三种方式
    //第一种方式
    login("wzx", "123", { msg: String, code: Int ->
        println("最终登录情况：msg:$msg code:$code")
    })
    //第二种方式
    login("wzx", "123", responseResult = { msg: String, code: Int ->
        println("最终登录情况：msg:$msg code:$code")
    })
    //第三种方式 《最好的方式》
    login("wzx", "123") { msg: String, code: Int ->
        println("最终登录情况：msg:$msg code:$code")
    }

    //TODO 内联函数 login2
    //只要函数参数有lamda，就要使用内联，例如 函数login(user: String, pwd: String, responseResult: (String, Int) -> Unit)
    //如果此函数不使用内联，在调用端，会生成多个对象来完成lamda调用，会造成性能损耗
    //如果此函数使用内联,相当于c++中 #define 宏定义，宏替换,h会把代码替换到调用处，调用处没有任何函数开辟，对象开辟的损耗。 login2()
    //小结：如果函数参数有lambda，尽量使用inline关键字，这样内部会做优化，减少函数开辟、对象开辟的损耗

    //TODO 函数引用
    //lambda属于函数类型的对象，需要把methodResonseResult普通函数变成函数类型的对象（函数引用）
    //函数login2 或者函数login中的responseResult函数可以单独拿出来实现，例如methodResonseResult。
    login2("wzx", "123", ::methodResonseResult)

    //也可以这样写
    val obj1 = ::methodResonseResult
    val obj2 = obj1
    login2("wzx", "123", obj1)
    login2("wzx", "123", obj2)

    //TODO 函数引用 函数类型作为返回类型
    val r = show2("学习KT语言") //r是show2的返回值
    val niming_method = show("学习KT语言")
    //niming_method 是 show的函数返回值，只不过这个返回值是一个函数
    //niming_method == 匿名函数
    niming_method("wzx", 18)

    //TODO 匿名函数和具名函数
    //匿名函数
    showPersonInfo("wzx", 18) {
        println("显示结果：$it")
    }
    //具名函数
    showPersonInfo("wzx", 18, ::showResultMethod)
}


fun login(user: String, pwd: String, responseResult: (String, Int) -> Unit) {
    if (user == "wzx" && pwd == "123") {
        responseResult("登录成功", 200)
    } else {
        responseResult("登录失败", 444)
    }
}

inline fun login2(user: String, pwd: String, responseResult: (String, Int) -> Unit) {
    if (user == "wzx" && pwd == "123") {
        responseResult("登录成功", 200)
    } else {
        responseResult("登录失败", 444)
    }
}

// login/login2 中responseResult的实现
fun methodResonseResult(msg: String, code: Int) {
    println("最终登录情况：msg:$msg code:$code")
}

//函数返回return一个匿名函数
fun show(info: String): (String, Int) -> String {
    println("我说show函数 info$info")
    //retrun 一个匿名函数
    return { name: String, age ->
        Int
        "我就是匿名函数"
    }
}

fun show2(info: String): String {
    return "我说show函数 info$info"
}

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

fun showResultMethod(str: String) {
    println("显示结果：$str")
}