Kotlin函数

发表于 | 分类于 ， | | 本文总阅读数 次
| 字数统计: 1.8k | 阅读时长 ≈ 7
Kotlin函数

2

Kotlin函数

  函数是面向过程的程序设计精髓，也是所有语言中最重要的一个内容，学好函数，可以设计出优雅的程序，下面给小伙伴们介绍Kotlin函数的定义，调用，参数传递，声明，默认参数，占位参数和函数的重载。

函数定义

1
2
3
4
5
6
7
8
9
10
11
// 函数小伙伴们其实并不陌生，在第一行Kotlin代码中就用到了函数的知识，main函数，main函数是程序运行的起始位置，程序必须要有main函数才可以运行
// 函数的定义包括权限修饰符，fun关键字，函数名，参数列表，返回值类型和函数体，和Java不同点在于有fun关键字，参数的类型写在参数后面，并且用冒号分隔，而且返回值不是写在函数名前面，而是写在形参后面，也使用冒号分隔，关于函数的权限修饰符会在面向对象中进行详细介绍。
// 这里单独强调返回值，返回值代表函数运行结束后返回到调用处时产生的数据，如果没有返回值，类型省略或写Unit，可以省略return，如果有返回值，一定要写return
// 调用时有两种方式，按照顺序传入参数，也可以通过形参名传入对应的参数，但是要注意一旦某个位置使用形参名传入参数，后面的所有参数都要使用这种方式
fun main() {
    println("1 + 2 = ${mySum1(1, 2)}")
}

fun mySum1(x: Int, y: Int): Int{
    return x + y
}

1

单表达式函数

1
2
3
4
5
6
//当函数只有一行代码，可以将花括号改为等号，并将函数体放在等于号的后面，而且可以省略返回值的类型进行自动推断
fun main() {
    println("1 + 2 = ${mySum2(1, 2)}")
}

fun mySum2(x: Int, y: Int) = x + y

4

默认参数

1
2
3
4
5
6
7
8
// 默认参数是指函数的某个参数具有默认的值，当没用指定该值时，会代入默认值使用，但是要注意默认参数的使用顺序。
// 在本例中，第二个参数y为默认参数，在函数定义时在后面写上默认值。调用时如果默认参数后面有普通参数，那么省略默认参数时，必须使用形参名来确定传入的值，否则会将该值当作默认参数传入。比如本例传入(1, 3)则会将x = 1，y = 3传入，此时会因为没用给z赋值而报错，有两种方法可以修改，一个是传入(1, z = 3)，这时指定传入的3是给z这个形参的。也可以给y传入一个数，这样3就会自动顺延至z。注意一般不在默认参数后面赋值普通参数，都将默认参数放在最后。
fun main() {
    println("1 + 2 + 3 = ${mySum3(1, z = 3)}")
    println("1 + 3 + 5 = ${mySum3(1, 3, 5)}")
}

fun mySum3(x: Int, y: Int = 2, z: Int) = x + y + z

1

函数重载

1
2
3
4
5
6
7
8
9
10
11
12
// 函数重载是指定义具有相同名字的函数，前提是函数的参数个数、顺序、类型不完全相同。在调用时更符合哪一个函数则调用哪一个函数。如mySum4(1.0, 2)此时参数为Double和Int，则调用mySum4(x:Double, y:Int)函数；如mySum4(1, 2.0)此时参数为Int和Double，则调用mySum4(x:Int, y:Double)函数；如果此时有一个函数为mySum4(x:Int, y:Double, z:Int = 2)此时仍然调用上面的函数，因为调用的函数具有两个实参，会优先使用具有两个形参的函数。如果调用的函数有三个实参，才会调用具有默认参数的函数。
fun main() {
    println("1 + 2 = ${mySum4(1.0, 2)}")
    println("1 + 2 = ${mySum4(1, 2.0)}")
    println("1 + 2 + 3 = ${mySum4(1, 2.0, 3)}")
}

fun mySum4(x:Int, y:Double) = x + y

fun mySum4(x:Int, y:Double, z:Int) = x + y + z

fun mySum4(x:Double, y:Int) = x + y

1

函数重载

1
2
3
4
5
6
7
8
9
10
11
12
// 函数重载是指定义具有相同名字的函数，前提是函数的参数个数、顺序、类型不完全相同。在调用时更符合哪一个函数则调用哪一个函数。如mySum4(1.0, 2)此时参数为Double和Int，则调用mySum4(x:Double, y:Int)函数；如mySum4(1, 2.0)此时参数为Int和Double，则调用mySum4(x:Int, y:Double)函数；如果此时有一个函数为mySum4(x:Int, y:Double, z:Int = 2)此时仍然调用上面的函数，因为调用的函数具有两个实参，会优先使用具有两个形参的函数。如果调用的函数有三个实参，才会调用具有默认参数的函数。
fun main() {
    println("1 + 2 = ${mySum4(1.0, 2)}")
    println("1 + 2 = ${mySum4(1, 2.0)}")
    println("1 + 2 + 3 = ${mySum4(1, 2.0, 3)}")
}

fun mySum4(x:Int, y:Double) = x + y

fun mySum4(x:Int, y:Double, z:Int) = x + y + z

fun mySum4(x:Double, y:Int) = x + y

1

可变参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 可变参数指参数类型确定，但是个数不确定的参数，可以通过vararg关键字来标识，在使用时可以当作数组，具有数组的高阶函数。对于可变参数可以使用星号*加数组名将数组进行展开传入。
// 要注意的是可变参数一般都位于函数的末尾，如果不在函数末尾，则后面的参数需要通过形参名传入
fun main() {
    println(mySum5(1))
    println(mySum5(1, 2))
    println(mySum5(1, 2, 3))
    println(mySum5(1, 2, 3, 4))
    val arr = intArrayOf(1, 2, 3, 4, 5)
    println(mySum5(*arr))
}

fun mySum4(x:Int, y:Double) = x + y

fun mySum4(x:Int, y:Double, z:Int) = x + y + z

fun mySum4(x:Double, y:Int) = x + y

1

局部函数

1
2
3
4
5
6
// 局部参数又称为嵌套函数，是在一个函数的内部定义另一个函数，在Python中也有类似的定义方式。
// 注意：如果内部和外部具有相同的函数，不会报错，调用时会使用内部的函数。如果内部和外部具有相同的函数，不同的参数，则优先使用内部的函数。如内部是mySum(x:Int, y:Int, z:Int = 2) = x + y + z，外部是mySum(x:Int, y:Int) = x + y，如果调用传入两个参数，仍然也使用内部的函数，这和函数重载不同，函数重载会使用外部的函数，因为参数更加匹配，内外部函数的原则是能用则使用内部函数，内部函数不能用才使用外部函数。当调用传入三个参数，则内部的函数无法使用，此时会调用外部的函数
fun main() {
    fun mySum6(x:Int, y:Int) = x + y
    println(1 + 2 = ${mySum6(1, 2)})
}

1

Kotlin小结

  函数是我们面向过程编程的重要思想，同时也是面向对象中封装特性的体现，有了函数我们可以节约大量的时间和空间管理我们的代码，提高了代码的复用率，但是我们要注意编程习惯，尽量一个函数实现一个功能，不要将多个功能写在同一个函数之中。

-------------本文结束感谢您的阅读-------------
0%