0%

Kotlin 学习记录（函数）

Posted on Edited on

Kotlin 学习记录 


1
本文只记录重要的或者与C/C++、Java 出入较大的内容

Kotlin 函数

  1. 默认参数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    fun defArgs(numA : Int  = 1, numB : Float = 2f, numC : Boolean = false){
        println("numA  =  $numA \t numB = $numB \t numC = $numC")
    }

    fun main(args: Array<String>) {
        
        // 默认参数的函数使用
        defArgs()
        defArgs(1,10f,true)
    }

  1. 命名参数

    1
    callFun("str",isTrue = true,numA = 3) //java中不支持这么写

  1. 可变参数

    ​ 当一个函数中的参数是不定数量的个数并且是同一个类型，则可是使用vararg修饰符去修饰这个变量，则被vararg修饰的参数相当于一个固定类型的数组。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    fun varargFun(numA: Int, vararg str : String){
            // 遍历
        for (s in str) {
            
        }

    // 获取元素
    //    str[index]
    //    str.component1() ... str.component5()

    // 或者其高阶函数用法
    //    str.map {  }
    //    str.filter {  }
    //    str.sortBy {  }

    }

    /*
    普通传递 : varargFun(1,"aaa","bbb","ccc","ddd","fff")
    数组传递：
            val strArray = arrayOf("aaa","bbb","ccc","ddd","fff")
            varargFun(1,*strArray) // *叫做伸展操作符
     */

  1. 单表达式函数

    ​ 函数具备返回值的时候，可以省略花括号并且在=赋值符号之后指定代码体，而函数的返回值是有编辑器自动推断的

    1
    2
    3
    4
    5
    6
    7
    8
    // 无参数的情况
    fun test1() = 2                     // 自动推断为：返回类型为Int

    // 有参数的情况
    fun test2(num : Int) = num * 2      // 自动推断为：返回类型为Int

    // 或者
    fun test3(x : Float, y : Int = 2) = x * y  // 和默认参数一起使用，返回值为Float型

高阶函数

将函数作为参数或者返回值的函数称为高阶函数。

  1. 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    ///函数作为参数
    private fun resultByOpt(num1 : Int , num2 : Int , result : (Int ,Int) -> Int) : Int{
        return result(num1,num2)
    }

    private fun testDemo() {
        val result1 = resultByOpt(1,2){
            num1, num2 ->  num1 + num2
        }

        val result2 = resultByOpt(3,4){
            num1, num2 ->  num1 - num2
        }

        val result3 = resultByOpt(5,6){
            num1, num2 ->  num1 * num2
        }

        val result4 = resultByOpt(6,3){
            num1, num2 ->  num1 / num2
        }

        println("result1 = $result1")
        println("result2 = $result2")
        println("result3 = $result3")
        println("result4 = $result4")
    }
  2. 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    ///返回值为函数
    fun test5(a:Int):()->Int{
        println("")
        var b = 3
        return fun():Int{
            println("b=> $b")
            b++
            return b + a
        }
    }

常用的标准高阶函数

  1. TODO函数：将会抛出异常，根据参数的内容输出异常内容

  2. run函数：两种用法

    ​ 当我们需要执行一个代码块的时候就可以用到这个函数,并且这个代码块是独立的。即我可以在run()函数中写一些和项目无关的代码，因为它不会影响项目的正常运行。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    private fun testRun1() {
        val str = "kotlin"

        run{
            val str = "java"   // 和上面的变量不会冲突
            println("str = $str")
        }

        println("str = $str")
    }

​ 因为run函数执行了我传进去的lambda表达式并返回了执行的结果，所以当一个业务逻辑都需要执行同一段代码而根据不同的条件去判断得到不同结果的时候。可以用到run函数

1
2
3
4
5
6
7
8
9
10
11
val index = 3
val num = run {
    when(index){
        0 -> "kotlin"
        1 -> "java"
        2 -> "php"
        3 -> "javaScript"
        else -> "none"
    }
}.length
println("num = $num")

​ 被一个对象所调用。当我们传入的lambda表达式想要使用当前对象的上下文的时候，我们可以使用这个函数。

1
2
3
4
5
6
val str = "kotlin"
str.run {
    println( "length = ${this.length}" )
    println( "first = ${first()}")
    println( "last = ${last()}" )
}
  1. 同时还有with / let / apply / also / takeIf() / takeUnless / repeat() / lazy() 分别有不同的用法