1. 函数的定义；
2. 函数的调用；
3. 函数的返回值。
分为下面5个类别：
1.定义函数
2.函数调用
3.函数规则
4.函数返回多个值
5.元组
Scala既是一个面向对象编程的语言，也是一个面向函数编程的语言。Scala中的函数和方法的语法是相同的，只是意义不同。Java中并没有函数和方法的区分，因为Java是面向对象编程的语言。
从不同的角度理解Scala函数会有不同的定义，如果一个函数作为某一对象的成员，那么这种函数就称为方法。如果从面向函数的角度理解Scala函数，那么Scala函数会具有面向函数式编程的特性。
（一）定义函数
格式如下：
注意：
1. 特别注意要写=
2. 返回值类型要指定
（二）函数调用
如比较函数大小等：
object Main {
// 定义一个函数
// 功能：求两个数的较大者
def max(x: Int, y: Int): Int = {
if (x > y)
x
else
y
}
def main(args: Array[String]): Unit = {
val rst = max(1, 100)
println(s"$rst")
}
}
object Main {
// 定义一个函数
// 功能：求两个数的较大者
// 格式：
// 1. 有一个 =
// 2. 返回值类型。
// 函数内的最后一个表达式或者语句的值，就是函数的返回值。
def max(x: Int, y: Int): Int = {
val t = if (x > y) x else y
t // 就是返回值
}
// Unit 表示没有返回值，调用这个函数时，不会接收到任何的处理结果。
// 如果一个函数不需要参数，可以省略()
def say: Unit = {
println("hahahaha~~~")
}
def main(args: Array[String]): Unit = {
val rst = max(1, 100)
println(s"$rst!")
// 调用一个没有()的函数，也不要加()
say
}
}
求三个数的最大值
object Main {
// 定义一个函数
// 功能：求三个数的较大者
def max(x: Int, y: Int, z: Int): Int = {
val temp = if (x > y) x else y
val result = if (temp > z) temp else z
result // 就是返回值
}
def main(args: Array[String]): Unit = {
val rst = max(1, 10, 100)
println(s"$rst!")
}
}
（三）函数规则
1.只有一行可以省略{}。当Scala的函数体中只有一行表达式时可以省略{}，输出结果依然不变。
2.最后一条语句为函数的返回值。当函数体中有多个语句存在时，返回最后一条语句的值。
3.函数的返回类型可以省略。它会自动推断。
4.函数没有形参，在定义函数时可以省略()，那么在调用函数时也不需要添加()
例如：
object Main {
// 方法1：两次二选一（代码中的方法）
def max_method1(x: Int, y: Int, z: Int): Int = {
val temp = if (x > y) x else y // 第一次二选一
if (temp > z) temp else z // 第二次二选一
}
// 方法2：三选一（注释中提到的方法）
def max_method2(x: Int, y: Int, z: Int): Int = {
if (x >= y && x >= z) {
x
} else if (y >= x && y >= z) {
y
} else {
z
}
}
def main(args: Array[String]): Unit = {
println("两种方法求三个数的最大值：")
val test1 = (1000, 200, 100)
val test2 = (50, 300, 100)
val test3 = (10, 20, 30)
val test4 = (5, 5, 5) // 相等的情况
println(s"测试数据: $test1")
println(s"方法1结果: ${max_method1(test1._1, test1._2, test1._3)}")
println(s"方法2结果: ${max_method2(test1._1, test1._2, test1._3)}")
println(s"\n测试数据: $test2")
println(s"方法1结果: ${max_method1(test2._1, test2._2, test2._3)}")
println(s"方法2结果: ${max_method2(test2._1, test2._2, test2._3)}")
println(s"\n测试数据: $test3")
println(s"方法1结果: ${max_method1(test3._1, test3._2, test3._3)}")
println(s"方法2结果: ${max_method2(test3._1, test3._2, test3._3)}")
println(s"\n测试数据: $test4")
println(s"方法1结果: ${max_method1(test4._1, test4._2, test4._3)}")
println(s"方法2结果: ${max_method2(test4._1, test4._2, test4._3)}")
}
}
（四）函数返回多个值
例如：
object Main {
// 定义一个函数
// 功能：求三个数的最大值和最小值。
// 注意：函数需要返回多个值。把要返回的数组使用()包在一起，成为一个整体
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
// 返回一个元组（最小值，最大值）
(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
访问元组
元组通过Tuple_INDEX的方式访问元组中的元素，Tuple表示元组，INDEX表示索引。
object Main {
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)
}
}
