1.方法定义和调用

object HelloWord {
  def main(args: Array[String]) {
    println("Returned Value : " + addInt(5, 7));  // addInt(5, 7)调用定义的addInt方法
  }

  def addInt(a: Int, b: Int): Int = {    // a: Int 数据类型    : Int类型
    var sum: Int = 0
    sum = a + b
    return sum
  }
}

结果
Returned Value : 12

2.传值调用

先计算参数表达式的值，再应用到函数内部
object HelloWord {
  def main(args: Array[String]) {
    delayed(time());
  }

  def time() = {
    println("获取时间，单位为纳秒")
    System.nanoTime
  }

  def delayed(t: Long) = {
    println("在 delayed 方法内")
    println("参数： " + t)
  }
}

结果
获取时间，单位为纳秒
在 delayed 方法内
参数： 325499987637800

3.传名调用

将未计算的参数表达式直接应用到函数内部

object HelloWord {
  def main(args: Array[String]) {
    delayed(time());
  }

  def time() = {
    println("获取时间，单位为纳秒")
    System.nanoTime
  }

  def delayed(t: => Long) = { // =>设置传名调用
    println("在 delayed 方法内")
    println("参数： " + t)
  }
}

结果
在 delayed 方法内
获取时间，单位为纳秒
参数： 325578016530300

4. 函数 - 可变参数

object HelloWord {
  def main(args: Array[String]) {
    printStrings("Runoob", "Scala", "Python");
  }

  def printStrings(args: String*) = {   // * 设置可变参数(可重复的参数)
    var i: Int = 0;
    for (arg <- args) {
      println(s"Arg value[ + ${i} + ] =  + ${arg}");  // ${} 占位符 自动替换
      i = i + 1;
    }
  }
}

结果
Arg value[0] = Runoob
Arg value[1] = Scala
Arg value[2] = Python

5.闭包

函数内引用函数外的变量

object HelloWord {
  def main(args: Array[String]) {
    println("muliplier(1) value = " + multiplier(1))
    println("muliplier(2) value = " + multiplier(2))
  }

  var factor = 3
  val multiplier = (i: Int) => i * factor
}

结果
muliplier(1) value = 3
muliplier(2) value = 6

6.偏应用函数

偏应用函数是一种表达式，你不需要提供函数需要的所有参数，只需要提供部分，或不提供所需参数。

import java.util.Date
object HelloWord {
  def main(args: Array[String]) {
    val date = new Date
    val logWithDateBound = log(date, _: String)   // log函数需要两个参数, 这样定义就不要每次都带data这个参数

    logWithDateBound("message1")
    Thread.sleep(1000)
    logWithDateBound("message2")
    Thread.sleep(1000)
    logWithDateBound("message3")
  }

  def log(date: Date, message: String) = {
    println(date + "----" + message)
  }
}

结果
Sat Jul 25 15:23:25 CST 2020----message1
Sat Jul 25 15:23:25 CST 2020----message2
Sat Jul 25 15:23:25 CST 2020----message3

7.递归函数

函数可以调用它本身。

object HelloWord {
  def main(args: Array[String]) {
    for (i <- 1 to 10)
      println(i + " 的阶乘为: = " + factorial(i))
  }

  def factorial(n: BigInt): BigInt = {
    if (n <= 1)
      1
    else
      n * factorial(n - 1)
  }
}

结果
1 的阶乘为: = 1
2 的阶乘为: = 2
3 的阶乘为: = 6
4 的阶乘为: = 24
5 的阶乘为: = 120
6 的阶乘为: = 720
7 的阶乘为: = 5040
8 的阶乘为: = 40320
9 的阶乘为: = 362880
10 的阶乘为: = 3628800

8.高阶函数

高阶函数可以使用其他函数作为参数，或者使用函数作为输出结果

object HelloWord {
  def main(args: Array[String]) {
    println(apply(layout, 10))

  }

  // 函数 f 和 值 v 作为参数，而函数 f 又调用了参数 v    f: Int => String 传名调用
  def apply(f: Int => String, v: Int) = f(v)

  def layout[A](x: A) = "[" + x.toString() + "]"
}

结果
[10]

9.匿名函数

object HelloWord {
  def main(args: Array[String]) {
    println("multiplier(1) value = " + multiplier(1))
    println("multiplier(2) value = " + multiplier(2))
  }

  var factor = 3
  val multiplier = (i: Int) => i * factor   // =>左边是参数列表，右边是函数体。
}

结果
multiplier(1) value = 3
multiplier(2) value = 6