Scala的函数基础Ⅰ

函数的定义：

def 函数名(参数列表): 返回值类型 = { // 函数体（执行逻辑） 
// 最后一个表达式的结果会作为返回值（无需显式使用return）
}

函数调用:

格式：返回值=函数(参数列表)

def getSum(x:Int, y:Int): Int = {
     x + y
}  
val s = getSum(10,20)  
printf(s)

函数规则：

1.只有一行可以省略{}。当Scala的函数体中只有一行表达式时可以省略{}，输出结果依然不变。
2.最后一条语句为函数的返回值。当函数体中有多个语句存在时，返回最后一条语句的值。
3.函数的返回类型可以省略,它会自动推断。
4.函数没有形参，在定义函数时可以省略()，那么在调用函数时也不需要添加()

案例

案例1：

定义一个函数，求两个数的较大者。

object day6 {
  def max(x: Int, y: Int): Int = {
    val t = if (x > y) x else y
    t // 最后一个表达式的值作为返回值
  }
  // 如果一个函数不需要参数，可以省略()
  def say: Unit = {
    println("aaaaa~~~")
  }
  def main(args: Array[String]): Unit = {
    val rst = max(1, 100)
    println(s"${rst}")  // 会输出100
    say  // 调用无参数函数
  }
}

案例2：

定义一个函数，求三者的较大者。

方法一：两次二选一

object day06 {
  def max(x: Int, y: Int,z:Int): Int = {
    val t = if (x > y) x else y
    t // 最后一个表达式的值作为返回值
    val result = if (t > z) t else z
    result // 最后一个表达式的值作为返回值
  }
  def say: Unit = {
    println("aaaaa~~~")
  }
  def main(args: Array[String]): Unit = {
    val rst = max(1,10, 100)
    println(s"${rst}")  // 会输出100
    say  // 调用无参数函数
  }
}

方法二：三选一

object day06 {
  def max(x: Int, y: Int, z: Int): Int = {
    if (x >= y && x >= z) {
      x
    } else if (y >= x && y >= z) {
      y
    } else {
      z
    }
  }
  def say: Unit = {
    println("aaaaa~~~")
  }
  def main(args: Array[String]): Unit = {
    val rst = max(1, 10, 100)
    println(s"${rst}")  // 会输出100
    say  // 调用无参数函数
  }
}
    

案例3：

定义一个函数，求三个数中的最大值，最小值。

object day061 {
  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) x else y
    minValue = if (minValue < z) minValue else z
    // println(minValue, maxValue)
    (minValue, maxValue) // 是一个整体
  }
  def main(args: Array[String]): Unit = {
    val rst = max(1000, 200, 100)
    // 访问这个整体中的某个值： ._数字
    println(s"最小值是：${rst._1}，最大值是：${rst._2}")
  }
}

注意：函数需要返回多个值，把要放回的数据使用（）包在一起，成为一个整体

元组

什么是元组？

元组表示不同类型值的集合，即元组可以用于存放不同类型的元素，例如可以存放整型、字符串、浮点型、自定义类型等等。Scala的元组类型可以使方法同时返回多个值，省略了中间部分的解析和集合的遍历。

定义

第一种表示方式为：（元素1，元素2，…元素N）

第二种表示方式为：new TupleN（元素1，元素2，…元素N）。N最大为22

案例:

object day62{
  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)
  }
}