Kotlin中的函数、递归、Lambda表达式与内联函数详解

### Kotlin 中的函数、递归、Lambda 表达式与内联函数详解 #### 1. 函数参数传递 在 Kotlin 中，函数参数传递有多种方式，下面我们通过 `students` 函数来详细介绍。 ```kotlin fun students(names: String="Praniti", standard: String="IX", roll_no: Int=11) { println("The Name of the students is: $names") println("The Standard of the students is: $standard") println("The Roll no of the students is: $roll_no") } ``` 这个函数接受三个参数：`names`、`standard` 和 `roll_no`，并且为每个参数都设置了默认值。 ##### 1.1 不传递参数调用函数 ```kotlin fun main(args: Array<String>) { val names_of_students = "Gautam" val standard_of_students = "VII" val roll_no_of_students = 23 students() } ``` 当调用 `students` 函数时不传递任何参数，函数将使用默认参数作为函数参数，并将默认值输出到标准输出。 ##### 1.2 传递部分参数调用函数 ```kotlin fun main(args: Array<String>) { val names_of_students = "Gautam" val standard_of_students = "VII" val roll_no_of_students = 24 students(names_of_students,standard_of_students) } ``` 这里只传递了 `names` 和 `standard` 两个参数，对于 `roll_no`，函数将使用默认值（这里是 13），并将所有值输出到标准输出。 ##### 1.3 传递所有参数调用函数 ```kotlin fun main(args: Array<String>) { val names_of_students = "Gaurav" val standard_of_students = "VIII" val roll_no_of_students = 25 students(names_of_students,standard_of_students,roll_no_of_students) } ``` 当传递所有参数时，传递的值将覆盖函数参数的默认值，函数将只打印调用时传递给形式参数的值。 ##### 1.4 命名参数 在使用默认参数时，如果参数顺序混乱，会导致编译错误。因此，必须按照函数定义中的顺序将实际参数提供给形式参数。不过，Kotlin 支持命名参数，即通过参数名来传递参数。 ```kotlin fun main(args: Array<String>) { val name_of_students = "Gautam" val standard_of_students = "VII" val roll_no_of_students = 23 students(names=name_of_students,roll_no=roll_no_of_students) } ``` 这里只提供了 `name` 和 `roll_no` 的值，因此函数将打印“Students standard”的默认值。 #### 2. Kotlin 中的递归 递归是指函数调用自身的过程。在 Kotlin 中，递归函数的使用与其他编程语言类似。 ##### 2.1 正常函数调用 ```kotlin fun sum(a:Int, b:Int) : Int { val numb = a+b return numb } fun main( args: Array < String>) { sum() } ``` 当从 `main()` 块调用函数时，这被称为正常函数调用。在这个例子中，`sum()` 函数被调用一次，它执行其指令并返回数字的总和。如果想重新运行代码，必须再次从 `main` 块调用 `sum()`。 ##### 2.2 递归函数调用 ```kotlin fun callMe(a:Int) { println(a) if (a > 0) callMe(a - 1) } fun main (args: Array <String>) { var n = 5 callMe(n) } ``` 当函数调用自身时，这被称为递归函数调用。每个递归函数都应该包含一个终止条件，否则程序将进入无限循环，导致栈溢出错误。在这个例子中，终止条件是 `if (a > 0)`，函数将打印从 5 到 0 的值。 ##### 2.3 递归示例 - **计算阶乘（无终止条件）** ```kotlin fun Fact(numb: Int):Long{ return numb*Fact(numb-1) } fun main() { println("The Factorial of 5 is: "+Fact(5)) } ``` 这个程序没有终止条件，会导致无限递归，最终引发栈溢出错误。 - **计算阶乘（有终止条件）** ```kotlin fun Fact(numb: Int):Long{ return if(numb==1) numb.toLong() else numb*Fact(numb-1) } fun main() { println("The Factorial of 5 is: "+Fact(5)) } ``` 这里添加了终止条件 `if(numb==1)`，函数可以正确计算阶乘。 - **计算数组元素的总和** ```kotlin fun sum(args: Array<Int>, index:Int ):Int{ return if(index<=0) 0 else (sum(args, index-1) + args[index-1]) } fun main() { val array = arrayOf(11,22,33,44,55,66,77,88,99,100) val ny = array.size val result = sum(array,ny) println("Sum of array elements is: $result") } ``` 通过递归调用，每次将索引减 1，直到索引小于等于 0 时终止递归，最终返回数组元素的总和。 #### 3. Kotlin 中的尾递归 在传统的递归调用中，先进行递归调用，然后获取递归调用的返回值并计算结果。而在尾递归中，先进行计算，然后进行递归调用，并将当前步骤的结果传递给下一个递归调用。最终，普通递归和尾递归得到的结果是相同的。 尾递归的规则是递归调用必须是方法的最后一个调用。 ##### 3.1 尾递归的优点 - 在尾递归中，函数调用是函数执行的最后一项操作，当前函数中没有其他操作需要执行。因此，不需要在栈内存中保存当前函数调用，编译器可以将该栈空间重新用于下一个递归调用。 - 在程序执行过程中，尾递归不会出现 `StackOverflowError`。 ##### 3.2 尾递归示例 - **计算阶乘** ```kotlin fun Fact(numb: Int, x:Int):Long{ return if(numb==1) x.toLong() else Fact(numb-1,x*numb) } fun main() { var n = 1 var result = Fact(5,n) println("The Factorial of 5 is: $result") } ``` - **计算数组元素的总和** ```kotlin fun sum(args: Array<Int>, index:Int, s : Int = 0 ):Int{ return if(index<=0) s else sum(args, index-1, s + args[index-1]) } fun main() { val array = arrayOf(1,2,3,4,5,6,7,8,9,10) val nu = array.size val result = sum(array,nu) println("Sum of array elements is: $result") } ``` #### 4. Kotlin 中的 Lambda 表达式和匿名函数 Lambda 表达式和匿名函数在 Kotlin 中都是函数字面量，它们不是通过声明来定义的，而是作为表达式提供的。 ##### 4.1 Lambda 表达式 Lambd