Scala中的函数参数和递归函数

1.函数参数的默认值；

2.函数的变参；

3.无参函数

4.递归函数的定义；

5.递归函数的实现结构；

6.常见的递归函数。

（一）函数参数的默认值

1. 定义有默认值的函数

格式：def 函数名(参数1：类型1=默认值1,参数2：类型2=默认值2)

例如：

object Main {
  // gender:
  def greet(name: String = "哈哈", age: Int = 18, gender: String = "女"): Unit = { 
    println(s"我是${name}, 我今年${age}, ${gender}")
  }

  def main(args: Array[String]): Unit = {
    greet("小花", 18) // 默认值
    greet("小明", 20, "男")
    greet()
  }
}

（二）创建不带()的方法

如果函数没有参数，可以省略定义函数时的( )

例如：

object Main {
  def greet(name: String = "哈哈", age: Int = 18, gender: String = "女"): Unit = { 
    println(s"我是${name}, 我今年${age}岁, 性别${gender}")
  }

  def main(args: Array[String]): Unit = {
    println("=== 命名参数调用示例 ===")
    
    // 设置age为20，其他采用默认值
    print("只设置age: ")
    greet(age = 20)
    
    // 同时设置gender和age，name使用默认值
    print("设置gender和age: ")
    greet(gender = "男", age = 20)
    
    // 不按参数顺序，只设置特定参数
    print("只设置gender: ")
    greet(gender = "男")
    
    // 混合使用位置参数和命名参数
    print("混合使用: ")
    greet("小明", gender = "男")
  }
}

object Main {
  // 如果函数不需要参数，可以在定义函数的时候，省略()
  def greet: Unit = {
    println(s"hahhaa---")
  }

  def main(args: Array[String]): Unit = {
    // 如果在定义函数的时候没有写()，那么在调用函数的时候，也不要加()
    greet
  }
}

（三）创建接受变参的方法

在Scala中创建接受变参的方法为：参数类型*，这种方式只能接受同一类型的参数。

例如：

object Main {
  // 传入不同的轨里的参数
  // 第一个参数是学生的名字，从第二个参数开始，是这个学生的某单个学科的得分
  // 受参：允许传入不同个数，但是类型相同的参数
  // Int*
  // array 数组

  def greet(name: String, score: Int*): Unit = {
    // score 是一个列表
    var total: Double = 0
    for (i <- score) {
      total += i
    }
    val avg = total / score.length
    println(s"${name}, 平均分是:${avg}")
  }

  def main(args: Array[String]): Unit = {
    //
    greet("小花", 90, 100, 98, 100, 60)
    greet("小明", 80, 88)
    greet("小张", 90)
  }
}

（四）递归函数的定义和格式

递归是一种常用的解决问题的方法，特别适用于解决可以被分解为类似子问题的问题。递归函数通常由两个主要部分组成：起始条件（或基线条件）和递归规则（或递归关系）。

起始条件：一个递归的终止条件，确保递归不会无限进行。它处理最简单的情况并返回结果.

递归规则：在这个部分，函数会调用自身，以解决一个更小的子问题。

object Main {
  // 1 + 2 + 3 + 4 + ... + n
  def sum(n: Int): Int = {
    if (n == 1) {
      1  // 基准情况：当n=1时，返回1
    } else {
      sum(n - 1) + n  // 递归情况：sum(n) = sum(n-1) + n
    }
  }

  def main(args: Array[String]): Unit = {
    val s = sum(100)
    println(s)  // 输出：5050
  }
}

阶乘

object Main {
  // 求阶乘
  // f(n) = 1 * 2 * 3 * 4 * 5 .... * n
  def f(n: Int): Int = {
    // 完成你的代码
    if (n == 0 || n == 1) {
      1
    } else {
      n * f(n - 1)  // f(n) = n * f(n-1)
    }
  }

  def main(args: Array[String]): Unit = {
    val s = f(4)
    println(s) // 4*3*2*1 = 24
  }

  // 1 + 2 + 3 + 4 + ... + n
  def sum(n: Int): Int = {
    println(n)
    if (n == 1) {
      1
    } else {
      sum(n - 1) + n
    }
  }
}