scala 方法method与函数function

Scala 方法是类的一部分，而函数是一个对象可以赋值给一个变量。换句话来说在类中定义的函数即是方法。

Scala 中的方法跟 Java 的类似，方法是组成类的一部分。

Scala 中的函数则是一个完整的对象，Scala 中的函数其实就是继承了 Trait 的类的对象。

Scala 中使用 val 语句可以定义函数，def 语句定义方法和函数。

 

方法 method 

object s6_method {

  def main(args: Array[String]): Unit = {
    val a1 = Array(1, 2, 3, 4, 5, 6)
    println(sum(a1, 3))
    println(fbArray(5))
    printHello()
    printString()
    printString("HUST")
    println(add(4, 5, 6))
    println(add(b = 2))
    println(add1(1, 2, 3, 4))
  }

  // 递归方法必须指明返回类型，其它情况可省略
  def sum(array: Array[Int], k: Int): Int = {
    var res = 0
    for (elem <- array) {
      // forEach 循环
      res += {
        if (elem >= 3) elem else 0
      }
    }
    return res
  }

  def fbArray(n: Int): Int = { // 递归调用必须指明返回类型
    if (n < 0) return 0
    if (n == 0) return 0
    if (n == 1) return 1
    else return fbArray(n - 1) + fbArray(n - 2)

  }

  // 无参 Unit返回类型
  def printHello(): Unit = {
    println("Hello")
  }

  // 带默认参数的方法
  def printString(str: String = "Hello,Scala"): Unit = {
    println(str)
  }

  def add(a: Int = 1, b: Int, c: Int = 3): Int = {
    return a + b + c
  }

  // 可变长参数方法
  def add1(a: Int*): Int = {
    var sum = 0
    for (i <- a) sum += i
    return sum
  }

}

 

函数 function

object s7_function {
  def main(args: Array[String]): Unit = {
    val fun = (x: Int, y: Int) => x + y // 推荐使用
    println(fun(5, 6))

    val fun1 = (_: Int) + (_: Int)
    println(fun1(5, 6))

    val fun2: (Int, Int) => Int = (_ + _)
    println(fun2(5, 6))

    val f = new Function2[Int, Int, Int] {
      def apply(x: Int, y: Int) = x + y
    }
    println(f(5, 6))

    // 无参函数
    val f1 = () => println("Hello,scala")
    f1()

    val swap = (x: Int, y: Int) => (y, x)
    println(swap(5, 6))
  }
}

 

函数与方法的联系

object s8_methodFunc {
  def main(args: Array[String]): Unit = {
    // 函数作为方法的一个参数
    def method(f: (Int, Int) => Int, x: Int, y: Int) = f(x, y)

    val add = (x: Int, y: Int) => x + y
    println(method(add, 5, 6))

    // 函数作为函数的参数
    def sub(x: Int, y: Int) = x - y

    println(method(sub, 5, 6))

    println(sub _) // 方法显式转换为函数
    val f1 = sub _
    println(f1(5, 6))
  }

}