Scala 的函数基础 #Scala自适应类型和函数 #函数基础

1.Scala的函数参数的默认值 
1.1 定义参数默认值
在Scala中，你可以在函数定义时直接为参数指定默认值。如果调用函数时没有提供该参数的值，编译器会自动使用这个默认值。

1.1.1 函数参数的默认值  
object Test13 {
  // 1.函数参数的默认值
  // 定义一个函数
  def sum(x:Int=100 ,y:Int=100):Int={
    x+y
  }
  // 给参数一个默认值；如果调用时，没有传入参数，就直接使用默认值
 
  def main(args: Array[String]): Unit = {
    val rs1 =sum(1)
    println(rs1)
    val rs2 =sum(2)
    println(rs2)
    val rs3 =sum(1,1)
    println(rs3)
    var rs4 =sum(y=2)
    println(rs4)
  }
}

1.1.2 创建不带 （ ）的方法 
object Test13 {
  // 2. 创建不带 ( ) 的 方法
  // 如果函数不需要参数，所以可以在定义的时候直接省略 ( ) ---> 调用的时候，也要省略 ( )
//  def say():Unit ={}
  def say : Unit ={
    println("你好~~~")
  }
  def main(args: Array[String]): Unit = {
    say
    say
    say
  }
}
1.1.3  参数类型后面加  *
object Test14 {
  // 参数类型后面加*
  //如果定义一个函数，它直接接受数量不定的参数，并计算他们的累加？
  //  getSum(1,2) ==> 3
  //  getSum(1,2,3,4) ==> 10
  //  getSum(1,2,3,4,-5) ==> 5
  //  思路：把这些不确定个数的参数全部打包装在一个容器中！
  def getSum(x:Int*):Int={
    var sum =0
    for (i <- x){
      println(i)
      sum+=i
    }
    sum
  }
  def main(args: Array[String]): Unit = {
    var rs =getSum(1,2,3)
    println(rs)
  }
}

1.1.4  链式风格 ：在方法中返回当前对象
class Stu15 {
  def say(): this.type = {
    println("say.........")
    this  // 当前对象
  }
 
  def run():this.type = {
    println("run.........")
    this
  }
 
  def sleep(): this.type = {
    println("sleep.........")
    this
  }
}
 
object Test15 {
  def main(args: Array[String]): Unit = {
    val s1 =new Stu15()
    s1.say().run().sleep()
//    s1.run()
//    s1.sleep()
    //    args.map().foreach().toString
    // 链式风格： 在方法中返回当前对象！
    // 对象.方法1().方法2().方法3().方法4().
  }
}

1.2 参数默认值的作用 
提高代码的可读性：通过参数默认值，可以使函数调用更加简洁，同时保持函数的灵活性。
def log(message: String, level: String = "INFO"): Unit = {
  println(s"[$level] $message")
}
 
// 调用函数时，可以省略日志级别，使用默认值
log("这是一条信息")
// 输出：[INFO] 这是一条信息
 
// 也可以指定日志级别
log("这是一条警告", "WARNING")
// 输出：[WARNING] 这是一条警告
减少代码冗余：默认值可以减少重复代码，特别是在处理具有许多可选参数的函数时。
def createUser(name: String, role: String = "普通用户"): User = {
  // 创建用户的逻辑
  new User(name, role)
}
 
// 大多数情况下，我们创建的是普通用户
val user1 = createUser("Alice")
 
// 偶尔需要创建管理员用户
val admin = createUser("Bob", "管理员")
提高函数的灵活性：允许调用者根据需要选择性地提供参数值，而不是强制提供所有参数。
def sendEmail(to: String, subject: String, body: String, cc: String = ""): Unit = {
  // 发送邮件的逻辑
  println(s"发送邮件给: $to, 抄送: $cc, 主题: $subject, 内容: $body")
}
 
// 发送邮件，不需要抄送
sendEmail("alice@example.com", "会议通知", "明天下午3点开会")
 
// 发送邮件，需要抄送给多个接收者
sendEmail("bob@example.com", "项目更新", "项目进度已更新", "charlie@example.com,dave@example.com")
1.3 参数默认值的限制
位置参数：默认值只能用于函数的末尾参数。这意味着所有具有默认值的参数必须位于没有默认值的参数之后。
// 错误：默认值不能用于非末尾参数
// def printInfo(name: String = "Unknown", age: Int): Unit = ...
 
// 正确：默认值用于末尾参数
def printInfo(age: Int, name: String = "Unknown"): Unit = {
  println(s"Name: $name, Age: $age")
}
 
// 调用时可以省略name参数，因为它有默认值
printInfo(30)
 
// 也可以同时提供所有参数
printInfo(25, "Alice")
不可变参数：一旦为参数设置了默认值，该参数就不能再被修改或重写。
// 定义一个函数，其中有一个参数有默认值
def greet(name: String = "Guest"): Unit = {
  println(s"Hello, $name!")
}
 
// 正确：调用函数时可以不提供name参数，使用默认值
greet()
 
// 正确：调用函数时可以提供name参数，覆盖默认值
greet("Alice")
 
// 错误：不能在其他地方重写name参数的默认值
// def greet(name: String = "Guest", name: String = "Visitor"): Unit = ...
1.4 参数默认值的传递
当调用函数时，如果没有为具有默认值的参数提供值，Scala编译器会自动使用定义时指定的默认值。如果提供了值，那么提供的值将覆盖默认值。

// 定义一个函数，其中有一个参数有默认值
def By(price: Double, discount: Double = 0.1): Double = {
  price - (price * discount)
}
 
// 调用函数时没有提供discount参数，使用默认值0.1
val priceWithDefaultDiscount = calculateDiscount(100)
// 输出：90.0
 
// 调用函数时提供了discount参数，覆盖默认值
val priceWithCustomDiscount = calculateDiscount(100, 0.2)
// 输出：80.0