11Kotlin项目实操之高阶函数二

Posted 2021-07-27 清风百草

（1）一个人只要自己不放弃自己，整个世界也不会放弃你.
（2）天生我才必有大用
（3）不能忍受学习之苦就一定要忍受生活之苦，这是多么痛苦而深刻的领悟.
（4）做难事必有所得
（5）精神乃真正的刀锋
（6）战胜对手有两次，第一次在内心中.
（7）好好活就是做有意义的事情.
（8）亡羊补牢，为时未晚
（9）科技领域，没有捷径与投机取巧。
（10）有实力，一年365天都是应聘的旺季，没实力，天天都是应聘的淡季。
（11）基础不牢，地动天摇
（12）写博客初心：成长自己，辅助他人。当某一天离开人世，希望博客中的思想还能帮人指引方向.
（13）编写实属不易，若喜欢或者对你有帮助记得点赞+关注或者收藏哦~

【11】Kotlin项目实操之高阶函数二

文章目录

• 【11】Kotlin项目实操之高阶函数二
• • 1.使用高阶函数
  • • 1.1完成高阶登录
    • • 1.1.1在函数形参中定义高阶函数
      • 1.1.2在函数形参中使用别名定义高阶函数
      • 1.1.3高阶函数的调用
    • 1.2有返回值但无具体实现的高阶函数
    • • 1.2.1在函数参数中定义有返回值无实现的高阶函数
      • 1.2.2调用
    • 1.2.3高阶函数作为形参传递
    • 1.2.4高阶函数无参但有返回值
    • • 1.2.5高阶函数调用（无参但有返回值）
    • 1.3给泛型增加扩展函数
    • • 1.3.1扩展函数定义
      • 1.3.2定义普通函数
      • 1.3.3给普通函数添加扩展函数并调用扩展函数
      • 1.3.4扩展函数中使用高阶函数
      • 1.3.5简写为一行
      • 1.3.6将泛型T指定为高阶函数
    • 1.4 给泛型添加扩展函数
    • 1.5给Context添加一个toast
    • • 1.5.1定义
      • 1.5.2使用
    • 1.6泛型T作为高阶函数参数
    • • 1.6.1定义
      • 1.6.2使用
    • 1.6.3给高阶函数增加匿名函数
    • 1.7控制器
    • • 1.7.1定义
      • 1.7.2使用
  • 2.打赏鼓励
  • • 2.1微信打赏
    • 2.2支付宝打赏

1.使用高阶函数

（1）高阶函数可以理解为定义在函数中的函数
（2）一般在函数的形参中定义
（3）高阶函数在函数形参中定义，还可以在函数体中获得调用。
（4）本节重点就是用高阶函数给成员属性、函数、以及类（Context）作扩展

1.1完成高阶登录

/**
 * @author XiongJie
 * @version appVer
 * @Package com.gdc.kotlin.core.higherfun
 * @file
 * @Description:高阶函数实现登录
 * @date 2021-6-6 09:02
 * @since appVer
 */
fun main() {
    //1.登录
    loginEngine("Derry","123456")

    //2.高阶函数run
    /*run {

    }*/
}

/**
 * 1.对外暴露
 */
fun loginEngine(userName:String,userPwd:String):Unit{
    /*
        1.1使用高阶函数，调用高阶函数
        （1）{}中的内容等同于loginService参数中的高阶函数的实现体
        （2）name,pwd为两个形参
     */
    loginService2(userName,userPwd){
        name,pwd ->
        if(name == "Derry" && pwd=="123456"){
            println("恭喜:${name}登录成功")
        }else{
            println("登录失败，请检查用户名或密码")
        }
    }
}

/**
 * 1.登录服务
 * 1.1高阶函数的使用
 * （1）形参中使用无返回值的高阶函数
 * requestLogin:(String,String) -> Unit
 * （2）不对外暴露使用private关键字
 */
private fun loginService1(userName:String,userPwd:String,requestLogin:(String,String)
-> Unit){
    //高阶函数的实现
    requestLogin(userName,userPwd)
}

/**
 * 1.使用别名将高阶函数定义在外面
 */
private fun loginService2(userName:String,userPwd:String,requestLogin:RequestLogin)
        :Unit{
    //高阶函数的实现
    requestLogin(userName,userPwd)
}

/**
 * 1.对高阶函数再次封装
 * （1）使用别名
 * （2）类似于定义标准
 */
typealias RequestLogin = (String,String) -> Unit

1.1.1在函数形参中定义高阶函数

/**
 * 1.登录服务
 * 1.1高阶函数的使用
 * （1）形参中使用无返回值的高阶函数
 * requestLogin:(String,String) -> Unit
 * （2）不对外暴露使用private关键字
 */
private fun loginService1(userName:String,userPwd:String,requestLogin:(String,String)
-> Unit){
    //高阶函数的实现
    requestLogin(userName,userPwd)
}

1.1.2在函数形参中使用别名定义高阶函数

/**
 * 1.使用别名将高阶函数定义在外面
 */
private fun loginService2(userName:String,userPwd:String,requestLogin:RequestLogin)
        :Unit{
    //高阶函数的实现
    requestLogin(userName,userPwd)
}

/**
 * 1.对高阶函数再次封装
 * （1）使用别名
 * （2）类似于定义标准
 */
typealias RequestLogin = (String,String) -> Unit

1.1.3高阶函数的调用

/**
 * 1.对外暴露
 */
fun loginEngine(userName:String,userPwd:String):Unit{
    /*
        1.1使用高阶函数，调用高阶函数
        （1）{}中的内容等同于loginService2参数中的高阶函数的实现体
        （2）name,pwd为两个形参
     */
    loginService2(userName,userPwd){
        name,pwd ->
        if(name == "Derry" && pwd=="123456"){
            println("恭喜:${name}登录成功")
        }else{
            println("登录失败，请检查用户名或密码")
        }
    }
}

1.2有返回值但无具体实现的高阶函数

1.2.1在函数参数中定义有返回值无实现的高阶函数

/**
 * 1.高阶函数
 * （1）参数中声明高阶函数
 * responseResult:(Boolean)-> Unit表明高阶函数有返回值,但没有具体的实现
 *
 * （2）在函数内部传递高阶函数
 */
fun login(userName:String,userPwd:String,responseResult:(Boolean) -> Unit){
    //传递高阶函数
    loginEngine(userName,userPwd,responseResult)
}

1.2.2调用

    /**
     * 1.登录最终的需求,倒着写实现
     * （1）{}的实现中的it值来自于调用高阶函数的返回值
     */
    login("张三","123456"){
        if(it){
            println("最终得到的结果是登录成功")
        }else{
            println("最终得到的结果是登录失败")
        }
    }

1.2.3高阶函数作为形参传递

/**
 * 1.在函数内部完成登录功能
 * responseResult:(Boolean)表明高阶函数有返回值
 */
private fun loginEngine(userName:String,userPwd:String,responseResult:(Boolean) -> Unit){
    val DB_USER_NAME="张三"
    val DB_USER_PWD = "123456"
    if(userName == DB_USER_NAME && userPwd == DB_USER_PWD){
        //TODO 模拟做了很多业务逻辑
        // .......
        //调用高阶函数
        responseResult(true)
    }else{
        //TODO 模拟做了很多业务逻辑
        // .......
        responseResult(false)
    }
}

1.2.4高阶函数无参但有返回值

/**
 * 1.高阶函数
 * （1）高阶函数无参但有返回值
 *   mm:() -> Boolean
 * （2）高阶函数的返回值与函数的返回值没有任何关系
 * （3）return 9999表示的是loginTest函数的返回值
 * （4）mm:() -> Boolean，是高阶函数调用的返回值，其实现体在main中，{true},值为true
 */
fun loginTest(mm:() -> Boolean):Int{
    val result = mm()
    println("result:$result")
    return 9999
}

1.2.5高阶函数调用（无参但有返回值）

	/**
     * 1.有返回值的高阶函数调用
     * 1.1{}是高阶函数的实现区域，{}表示无参
     * 1.2{true}表示高阶函数的返回值
     */
    loginTest(){
        true
    }

1.3给泛型增加扩展函数

1.3.1扩展函数定义

/**
 * 1.给泛型增加扩展函数
 * （1）定义泛型T，定义泛型R
 * （2）T.myRun()表示给泛型增加扩展函数
 * （3）m:T.() -> R：
 * - 表示给扩展函数增加一个匿名函数
 * - 其中的m可以理解为高阶函数的方法名
 * - T.()表示给T增加一个匿名函数,这个匿名函数是给高阶函数用的
 * - 扩展函数的返回值为R
 */
fun<T,R>T.myRun(m:T.() -> R) : R{
    //调用匿名函数包含的高阶函数
    return m()
}

1.3.2定义普通函数

fun commont(){
    println("我就是方法")
}

1.3.3给普通函数添加扩展函数并调用扩展函数

    commont().myRun {
        println("扩展函数中的高阶函数执行返回后执行")
    }

1.3.4扩展函数中使用高阶函数

/**
 * 1.扩展函数中使用高阶函数
 * （1）将泛型T指定为高阶函数
 */
fun<T,R>T.myRun1(m:() -> R) : R{
    //调用高阶函数
    return m()
}

1.3.5简写为一行

fun<T,R>T.myRun2(m:() -> R) : R = m()

1.3.6将泛型T指定为高阶函数

 /**
     * 1.将泛型T指定为高阶函数,高阶函数的返回值为泛型
     * （1）高阶函数体返回值为boolean
     */
    commont().myRun2 { 
        true
    }

    /**
     * 1.将泛型T指定为高阶函数,高阶函数的返回值为泛型
     * （1）高阶函数体返回值为Int
     */
    commont().myRun2 {
        9999
    }

1.4 给泛型添加扩展函数

（1）可以将基本类型理解为泛型，普通函数也可以理解为泛型，它们都可以被泛型接纳
（2）可以为它们添加扩展函数，在扩展函数中又可以使用高阶函数
（3）而匿名函数又可以被高阶函数使用。

val nameS : String = "张三"
val ageS : Int = 0

fun main() {
    //1.扩展函数的使用
    common1().myRunOk {
        //1.高阶函数体实现
        "高阶函数返回值"
    }

    common1().myRunOk1 {
        //1.高阶函数体实现
        println("高阶函数体实现返回Boolen型")
        true
    }

    common1().myRunOk2 {
        //1.高阶函数体实现
        println("高阶函数体实现返回Double型")
        1.1
    }

    nameS.myRunOk1 { true }
    ageS.myRunOk2 { 22.0 }
}

fun common1() {
    println("普通函数执行")
}

/**
 * 1.给普通函数添加扩展函数
 *
 * 1.1给万能类型添加扩展函数
 *
 * （1）fun<万能类型> 万能类型.myRunOk()
 *
 * （2）给扩展函数的参数中定义高阶函数
 *  mm:() -> String:高阶函数返回值为String
 *
 *  （3）执行高阶函数
 */
fun<万能类型> 万能类型.myRunOk(mm:() -> String){
    //执行高阶函数
    mm()
}

fun<万能类型> 万能类型.myRunOk1(mm:() -> Boolean){
    //执行高阶函数
    mm()
}

fun<万能类型> 万能类型.myRunOk2(mm:() -> Double){
    //执行高阶函数
    mm()
}

1.5给Context添加一个toast

1.5.1定义

/**
 * 1.给Context添加扩展函数toast
 * （1）在可见范围内扩展，即在Context范围内扩展
 */
fun Context.toast(info:String){
    //this指的是扩展函数
    Toast.makeText(this,info,Toast.LENGTH_SHORT).show()
}

1.5.2使用

class ToastActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_toast)
        toast("张荣你好")
    }
}

1.6泛型T作为高阶函数参数

1.6.1定义

/**
 * 泛型T作为高阶函数参数
 * （1）myMethod是一个高阶函数
 */
fun<T,R> T.myLet(myMethod:(T)->R):R{
    //T 就是 this
    return myMethod(this)
}

1.6.2使用

val sex : Char = 'M'
val pwd : String = "张亮"

fun main() {

    common3().myLet {

    }

    sex.myLet {
        'M'
    }

    pwd.myLet {
        "李连杰"
    }
}

/**
 * 普通函数
 */
fun common3(){

}

1.6.3给高阶函数增加匿名函数

/**
 * 1.给高阶函数增加匿名函数
 * myMethod:T.(T)
 * R是返回值
 */
fun<T,R> T.myLet1(myMethod:T.(T)->R):R{
    //myMethod(this)
    return myMethod(this)
}

    //不让其返回it,而是this，则需要给高阶函数添加匿名函数
    common3().myLet1 {

    }

1.7控制器

1.7.1定义

/**
 * 1.如果你是true,我就执行你，否则不执行
 */
fun onRun(isRun:Boolean,myMethod:()->Unit){
    if(isRun){
        myMethod()
    }
}

1.7.2使用

fun main() {
    
    //1.调用写法1
    onRun(true){
        println("执行了")
    }

    //1.调用写法2
    onRun(true,{
        println("执行了")
    })

    //1.调用写法3
   var runVar =  Runnable {
        println("我是Runnable任务")
    }

    /**
     * 1.调用写法4
     * 1.1如果为真，则执行Runnable中的run函数
     */
    onRun(true,runVar::run)
}

2.打赏鼓励

感谢您的细心阅读，您的鼓励是我写作的不竭动力！！！

2.1微信打赏

2.2支付宝打赏