Kotlin匿名函数使用介绍

//可见性修饰符  函数关键字 方法法名     参数名 参数类型          返回值
private       fun      functionName(age: Int, name: String): String {
    return name   age;
}

fun main() {
    //通常调用方式
    fix("xiaohua", 20)
    //age已经给定默认值，此时可以不传参数
    fix("xiaohua")
}
//参数age 给定默认值
fun fix(name: String, age: Int = 18) {
    println(name   age)
}

  println( fix("xiaohua"))

//具名函数
fun sayHello(): String {
    return "Hello world！"
}
fun main() {
    //具名函数调用
    println(sayHello())
}

 val hello: String = "hello"

fun main() {
    //声明一个匿名函数，并赋值给变量sayHello
    val sayHello: () -> String = {
        "Hello world!"
    }
    //匿名函数调用
    println(sayHello())
}

fun main() {
    //声明一个匿名函数，并赋值给变量sayHello
    val sayHello: () -> String = {
        "Hello world!"
    }
    //打印函数变量
    println(sayHello)
}

fun main() {
    val sayHello: (name: String) -> String = { name ->
        "Hello $name!"
    }
    println(sayHello("HanMei"))
}

fun main() {
    val sayHello: (name: String) -> String = {
        "Hello $it!"
    }
    println(sayHello("HanMei"))
}

fun main() {
    val sayHello: (String, Int) -> String = { name, age ->
        "Hello $name$age"
    }
    println(sayHello("HanMei",18))
}

fun main() {
    val sayHello = {
        "Hello world!"
    }
    println(sayHello())
}

fun main() {
    val sayHello={ name:String ->
        "Hello $name!"
    }
    println(sayHello("HanMei"))
}

fun main() {
    val sayHello = { name: String, age: Int ->
        "Hello $name$age!"
    }
    println(sayHello("HanMei", 18))
}

//定义一个具名函数，接收一个String参数和一个函数参数happyNewYear
//happyNewYear: (name: String, year: Int) -> String 这个就是匿名函数的定义
fun sayhello(name: String, happyNewYear: (name: String, year: Int) -> String) {
    val year = 2022
    //在具名函数中调用传递进来的匿名函数
    println(happyNewYear(name,year))
}

fun main() {
    //定义一个匿名函数
    val happyNewYear = { name: String, year: Int ->
        "${name},happy ${year}!"
    }
    //调用具名函数，并把匿名函数当作参数传递
    sayhello("HanMei", happyNewYear)
}

fun main() {
    sayhello("HanMei", happyNewYear = { name: String, year: Int ->
        "${name},happy ${year}!"
    })
}

fun main() {
    sayhello("HanMei") { name: String, year: Int ->
        "${name},happy ${year}!"
    }
}

  val word = "HappyNewYear"
  var count = word.count()

    count =  word.count({ letter ->
        letter == 'a'
    })

count =  word.count { letter -> letter == 'a' }

count = word.count { it == 'a' }

fun happyNewYear(name: String, year: Int): String {
    return "$name happy $year"
}
fun sayhello(name: String, happyNewYear: (name: String, year: Int) -> String) {
    val year = 2022
    println(happyNewYear(name, year))
}

fun main() {
    //::happyNewYear这个就是函数的引用，
    sayhello("HanMei",::happyNewYear)
}

fun sayhello(): (String) -> String {
    return {
        val year = 2022
        "$it happy $year"
    }
}

fun main() {
    //调用sayhello得到这个匿名函数，并赋值给变量happyNewYear
    val happyNewYear = sayhello();
    //happyNewYear就是一个匿名函数，可以直接传参调用
    println(happyNewYear("HanMei"))
}

fun sayhello(): (String) -> String {
    val year = 2022
    return {
        "$it happy $year"
    }
}