函数的基本运用

（一）定义函数

（二）函数调用

（三）函数规则

（四）函数返回多个值

（五）元组

定义函数

格式如下：

object F01 {

  // 定义一个函数
  // 功能：求两个数的较大者
  // 格式：
  //    1.有一个 =
  //    2.返回值类型。
  //        函数内的最后一个表达式或者语句的值，就是函数的返回值。
  //        Unit 表示没有返回值，调用这个函数时，不会接收到任何的处理结果。
  def max(x:Int, y:Int):Int = {
    val t = if(x > y)  x else y

    t // 就是返回值
  }

  // 如果一个函数不需要参数，可以省略()
  def say():Unit = {
    printf("hahaha")
  }

  def main(args: Array[String]): Unit = {
    val rst = max(1,100)

    println(s"$rst")

    // 调用一个没有()的函数，也不要加()
    say()
  }
}

要点：

1. 特别注意要写 =

2. 返回值类型要指定

函数调用

求三个的较大者

object F02 {

  // 定义一个函数
  // 功能：求三个的较大者
  // 分析：
  /*
   * 1. 三选一
   * if(x>=y && x>=z){
     x
   } else if(y>=x&&y>=z){
     y
   } else{
     z
   }
   * 2. 两次二选一
   * var t = if(x>y) x else y
   * if(t>z) t else z
   */

  def max(x:Int, y:Int, z:Int):Int = {
    var t = if(x>y) x else y
    if(t>z) t else z
  }

  def main(args: Array[String]): Unit = {
    val rst = max(1000,200,100)
    println(s"${rst}")
  }
}

函数规则

1.只有一行可以省略{}。当Scala的函数体中只有一行表达式时可以省略{}，输出结果依然不变。

2.最后一条语句为函数的返回值。当函数体中有多个语句存在时，返回最后一条语句的值。

3.函数的返回类型可以省略。它会自动推断。

4.函数没有形参，在定义函数时可以省略()，那么在调用函数时也不需要添加()

函数返回多个值

求三个数的最大值和最小值

object F03 {

  // 定义一个函数
  // 功能：求三个数的最大值和最小值。
  // 注意：函数需要返回多个值。把要返回的数据使用()包在一起，成为一个整体

  def max(x:Int, y:Int, z:Int): (Int, Int) = {
    var maxValue = if(x>y) x else y
    maxValue = if(maxValue>z) maxValue else z

    var minValue = if(x>y) y else x
    minValue = if(minValue>z) z else minValue

    // println(minValue, maxValue)

    (minValue, maxValue) // 是一个整体
  }

  def main(args: Array[String]): Unit = {
    val rst = max(1000,200,100)
    // 访问这个整体中的某个值： ._数字
    println(s"最小值是：${rst._1}，最大值是:${rst._2}")
  }
}

元组

元组表示不同类型值的集合，即元组可以用于存放不同类型的元素，例如可以存放整型、字符串、浮点型、自定义类型等等。

object F04 {
  def main(args: Array[String]): Unit = {
    // 元组：容器，可以装入不同的数据类型的数据
    // 1. 定义一个元组。使用（）把数据包起来，就可以了。
    val t = (1, "1", 1.2, false, 0)

    // 2、取出元素，通过 ._数字序号 来访问
    // 取出 1.2
    println(t._3)
    // 取出false
    println(t._4)
  }
}