有名函数：
有名称的函数。

fun doSomething(age:Int = 2, flag:Boolean):String{
      return "result"
  }

doSomething(25,true)

   /**
    
    count()是个标准函数
   {  letter  ->letter=='s'} 是个匿名函数,作为 count()的参数

  */
  val totalS = "Mississippi".count({letter  ->
        letter=='s'
      })

  println(totalS)

 匿名函数:

 此函数没有名字,只有方法体。
  匿名函数通常将自己作为整体作为一个参数  传递给其他的函数,或者从其他的函数体中返回。
  匿名函数不需要return 关键字来返回数据,其默认自动返回函数体最后一行语句结果。

函数式类型:

匿名函数也是有类型的

匿名函数 可以当做变量 赋值给 函数类型变量

 匿名函数不需要return 关键字来返回数据,其默认自动返回函数体最后一行语句结果。

如下:

//变量 haha2 的类型:()->Unit 无参无返回值类型
val haha2:()->Unit

//变量 haha3 的类型:()->Unit 无参无返回值的匿名函数类型
 val haha3:()->Unit={ println( "哈哈2") }

扫描二维码关注公众号，回复： 13191846 查看本文章

 //变量 haha4 的类型:(String)->Unit 有参无返回值的匿名函数类型
  val  haha4:(String)->Unit={str:String->
        println(str)
        "$str 哈哈42" //最后一行表示该匿名函数的返回值 // 匿名函数不需要return 关键字来返回数据,其默认自动返回函数体最后一行语句结果。
        }
    haha4("haha4")
    haha4.invoke("haha4")

 //变量 blessingFunction0 的类型:()->String  无参的字符串的类型
 val blessingFunction0:()->String

//变量blessingFunction1的类型:()->String 返回一个匿名函数 { val holiday = "New Year." "Happy $holiday" }
    //变量blessingFunction1 是个无参字符串类型的(匿名)函数类型的变量
    val blessingFunction1:()->String = {
        val holiday = "New Year."
        "Happy $holiday"
    }
    blessingFunction1.invoke()


  //简写
    val blessingFunction11 = {
       val holiday = "New Year."
       "Happy $holiday"
   }
    blessingFunction11.invoke()

 val blessingFunction13:(String,Int) -> String = {name:String, year:Int ->
         val holiday = "New Year."
         "$name, Happy $holiday $year"
     }
     blessingFunction13.invoke("方明飞",34)
    //简写
    val blessingFunction12 = {name:String, year:Int ->
         val holiday = "New Year."
        "$name, Happy $holiday $year"
    }
    blessingFunction12.invoke("方明飞",34)

 //变量 blessingFunction2的类型是个匿名函数类型:(String) -> String    有参的字符串的类型
    val blessingFunction2:(String) -> String = { name ->
        val holiday = "New Year."
        "$name, Happy $holiday" //最后一行(字符串)表示该匿名函数的返回值
    }
    blessingFunction2("方明飞")
    blessingFunction2.invoke("方明飞")

 一个(匿名)函数作为另一个函数的参数

 val getDiscountWords = {goodsName:String, hour:Int ->
        val currentYear = 2027
        "${currentYear}年，双11${goodsName}促销倒计时：$hour 小时"
    }
    //常规法
    showOnBoard("卫生纸",getDiscountWords)
  //常规 匿名函数法
 showOnBoard("卫生纸",
        getDiscountWords={goodsName:String, hour:Int ->
            val currentYear = 2027
            "${currentYear}年，双11${goodsName}促销倒计时：$hour 小时"
        }

    )

  //lambda表达法
  showOnBoard("卫生纸"){goodsName:String, hour:Int ->
        val currentYear = 2027
        "${currentYear}年，双11${goodsName}促销倒计时：$hour 小时"
    }



/**
 *  一个匿名函数 作为另一个函数的参数
 * 参数: getDiscountWords: (String,Int) -> String 是个匿名函数
 *
 *
 * */
//具名函数
private inline fun showOnBoard(goodsName:String, getDiscountWords: (String,Int) -> String){
    val hour = (1..24).shuffled().last()
   
     getDiscountWords.invoke(goodsName,hour)
}

lambda的简略写法:

如果一个函数的最后一个参数是个lambda参数,或者一个函数的唯一的一个参数 是个lambda参数

那么括住lambda参数外面的一对圆括号就可以省略掉。

//函数最后一个参数是个lamda参数

 val getDiscountWords = {goodsName:String, hour:Int ->
        val currentYear = 2027
        "${currentYear}年，双11${goodsName}促销倒计时：$hour 小时"
    }

    showOnBoard("卫生纸",getDiscountWords)
    showOnBoard("卫生纸",getDiscountWords={goodsName:String, hour:Int ->
        val currentYear = 2027
        "${currentYear}年，双11${goodsName}促销倒计时：$hour 小时"
    })
    
  showOnBoard("卫生纸"){goodsName:String, hour:Int ->
        val currentYear = 2027
        "${currentYear}年，双11${goodsName}促销倒计时：$hour 小时"
    }

//具名函数
private fun showOnBoard(goodsName:String, getDiscountWords: (String,Int) -> String){
    val hour = (1..24).shuffled().last()
     getDiscountWords(goodsName,hour)
    getDiscountWords.invoke(goodsName,hour)
}

 //函数只有一个lambda参数

 val getDiscountWords = {goodsName:String, hour:Int ->
        val currentYear = 2027
        "${currentYear}年，双11${goodsName}促销倒计时：$hour 小时"
    }

 showOnBoard2(getDiscountWords)
 showOnBoard2(getDiscountWords={goodsName:String, hour:Int ->
         val currentYear = 2027
        "${currentYear}年，双11${goodsName}促销倒计时：$hour 小时"
    })

 //lambda的简略写法:去掉参数lambda 外面的括号()
  showOnBoard2 { goodsName: String, hour: Int ->
        val currentYear = 2027
        "${currentYear}年，双11${goodsName}促销倒计时：$hour 小时"
    }




private inline fun showOnBoard2(getDiscountWords: (String,Int) -> String){
    val hour = (1..24).shuffled().last()
     getDiscountWords("卫生纸",hour)
     getDiscountWords.invoke("卫生纸",hour)
}

lambda函数引用

我们知道把函数作为参数传递给其他的函数使用,出了lambda可以作为参数传递给一个函数作为参数。

kotlin 还提供了另外一个方法,传递函数的引用,函数引用可以把一个具名函数转换成一个函数值参(具名函数前加::)

函数类型(String)->String 作为一个函数的返回类型, 那么该函数的return 是个函数

函数configDiscountWords()的类型是个函数类型(String)->String  return 一个函数

  val getDiscountWords: (String) -> String = configDiscountWords()
    println(getDiscountWords("沐浴露"))


fun configDiscountWords(): (String) -> String{
    val currentYear = 2027
    val hour = (1..24).shuffled().last()
    return {goodsName: String ->
        "${currentYear}年，双11${goodsName}促销倒计时：$hour 小时"
    }
}

闭包: 

匿名函数就是lambda lambda就是闭包