Kotlin - 函数

Kotlin 是一种静态类型语言，因此，函数在其中扮演着重要的角色。我们对函数非常熟悉，因为我们在上一章的示例中一直在使用函数。函数是一段用于执行特定任务的代码块。所有现代编程语言都支持函数，它们也被称为方法或子程序。

从广义上讲，函数接收一些称为参数的输入，对这些输入执行某些操作，最后返回一个值。

Kotlin 内置函数

Kotlin 提供了许多内置函数，我们在示例中使用了一些内置函数。例如，print() 和 println() 是我们最常用的内置函数，用于将输出打印到屏幕上。

示例

fun main(args: Array<String>) {
   println("Hello, World!")
}

用户定义函数

Kotlin 允许我们使用关键字fun创建自己的函数。用户定义的函数接受一个或多个参数，执行操作，并将该操作的结果作为值返回。

语法

fun functionName(){  
   // body of function 
}  

定义函数后，我们可以在需要时调用它任意多次。以下是如何调用 Kotlin 函数的简单语法

functionName()

示例

以下是如何定义和调用一个用户定义函数的示例，该函数将打印简单的“Hello, World！”

fun main(args: Array<String>) {

   printHello()
   
}

fun printHello(){
   println("Hello, World!")
}

运行以上 Kotlin 程序后，将生成以下输出

Hello, World!

函数参数

用户定义的函数可以接受零个或多个参数。参数是可选的，可以根据需要使用。例如，我们上面定义的函数没有使用任何参数。

示例

以下是如何编写一个用户定义函数的示例，该函数将添加两个给定的数字并打印它们的和

fun main(args: Array<String>) {
   val a = 10
   val b = 20
   
   printSum(a, b)
   
}

fun printSum(a:Int, b:Int){

   println(a + b)
}

运行以上 Kotlin 程序后，将生成以下输出

30

返回值

Kotlin 函数根据需要返回一个值。同样，返回一个值也是完全可选的。

要返回一个值，请使用return关键字，并在函数的括号后指定返回类型

示例

以下是如何编写一个用户定义函数的示例，该函数将添加两个给定的数字并返回它们的和

fun main(args: Array<String>) {
   val a = 10
   val b = 20
   
   val result = sumTwo(a, b)
   println( result )
   
}

fun sumTwo(a:Int, b:Int):Int{
   val x = a + b
   
   return x
}

运行以上 Kotlin 程序后，将生成以下输出

30

返回 Unit 的函数

如果函数不返回有用的值，则其返回类型为Unit。Unit 是一种只有一个值的类型，该值为Unit。

fun sumTwo(a:Int, b:Int):Unit{
   val x = a + b
   
   println( x )
}

Unit 返回类型声明也是可选的。以上代码等价于

fun sumTwo(a:Int, b:Int){
   val x = a + b
   
   println( x )
}

Kotlin 递归函数

递归函数在许多场景中很有用，例如计算数字的阶乘或生成斐波那契数列。Kotlin 支持递归，这意味着 Kotlin 函数可以调用自身。

语法

fun functionName(){  
   ...
   functionName()
   ...
}  

示例

以下是如何计算数字 10 的阶乘的 Kotlin 程序

fun main(args: Array<String>) {
   val a = 4
   
   val result = factorial(a)
   println( result )
   
}

fun factorial(a:Int):Int{
   val result:Int
   
   if( a <= 1){
      result = a
   }else{
      result = a*factorial(a-1)
   }
   
   return result
}

运行以上 Kotlin 程序后，将生成以下输出

24

Kotlin 尾递归

如果函数调用自身是其执行的最后一个操作，则递归函数有资格进行尾递归。

示例

以下是如何使用尾递归计算数字 10 的阶乘的 Kotlin 程序。这里我们需要确保乘法在递归调用之前完成，而不是之后。

fun main(args: Array<String>) {
   val a = 4
   
   val result = factorial(a)
   println( result )
   
}

fun factorial(a: Int, accum: Int = 1): Int {
    val result = a * accum
    return if (a <= 1) {
        result
    } else {
        factorial(a - 1, result)
    }
}

运行以上 Kotlin 程序后，将生成以下输出

24

Kotlin 尾递归在计算阶乘或对大数进行其他处理时很有用。因此，为了避免java.lang.StackOverflowError，必须使用尾递归。

高阶函数

高阶函数是指将另一个函数作为参数和/或返回一个函数的函数。

示例

以下是一个接受两个整数参数 a 和 b 的函数，此外，它还接受另一个函数operation作为参数

fun main(args: Array<String>) {
   
   val result = calculate(4, 5, ::sum) 
   println( result )
   
}
fun sum(a: Int, b: Int) = a + b 

fun calculate(a: Int, b: Int, operation:(Int, Int) -> Int): Int {
    return operation(a, b)                                       
}

运行以上 Kotlin 程序后，将生成以下输出

9

这里我们调用高阶函数，传入两个整数值和函数参数::sum。这里::是 Kotlin 中按名称引用函数的表示法。

示例

让我们再看一个函数返回另一个函数的示例。这里我们定义了一个返回函数的高阶函数。这里(Int) -> Int表示square函数的参数和返回类型。

fun main(args: Array<String>) { 
   val func = operation() 
   println( func(4) )
   
}
fun square(x: Int) = x * x

fun operation(): (Int) -> Int {
    return ::square                                       
}

运行以上 Kotlin 程序后，将生成以下输出

9

Kotlin Lambda 函数

Kotlin lambda 是一个没有名称的函数，用花括号 {} 定义，它接受零个或多个参数以及函数体。

函数体写在变量（如果有）后面，后跟 -> 运算符。

语法

{variable with type -> body of the function}  

示例

fun main(args: Array<String>) { 

   val upperCase = { str: String -> str.toUpperCase() }  

   println( upperCase("hello, world!") )
   
}                           

运行以上 Kotlin 程序后，将生成以下输出

HELLO, WORLD!

Kotlin 内联函数

内联函数用inline关键字声明。使用内联函数可以提高高阶函数的性能。内联函数告诉编译器将参数和函数复制到调用站点。

示例

fun main(args: Array<String>) { 

   myFunction({println("Inline function parameter")})
   
}
inline fun myFunction(function:()-> Unit){
   println("I am inline function - A")

   function()
   
   println("I am inline function - B")
}                               

运行以上 Kotlin 程序后，将生成以下输出

I am inline function - A
Inline function parameter
I am inline function - B

fun main(args: Array<String>) {
   val a = 100000
   
   val result = factorial(a)
   println( result )
   
}

fun factorial(a:Int):Int{
   val result:Int
   
   if( a <= 1){
      result = a
   }else{
      result = a*factorial(a-1)
   }
   
   return result
}