Scala多样的定义方法

标准定义

def sum(x: Int, y: Int): Int = {
  x + y
}

新方式：字面量方式

var sum1 = (x: Int, y: Int) => {
  x + y
}
// 简写1, 代码只有一句, 可以省略{ }
var sum2 = (x: Int, y: Int) =>  x + y
// 简写2, 形参可以使用占位符来代替
var sum3:(Int,Int) => Int = _ + _
// 注意：(Int,Int) => Int    表示一种类型，是一个函数，需要两个Int类型的参数，返回一个Int类型的结果

把函数当作参数来使用

// op 本身是一个函数，它的第一个参数是一个函数类型，(Int,Int) => Int 是一个类型
var op = (callback:(Int,Int)=>Int,x:Int,y:Int) =>{
  callback(x,y)
}

把函数当作返回值

def main(args: Array[String]): Unit = {
  // f是一个函数，它的返回值也是一个函数
  var f = (x:Int) =>{
    var fn = (y:Int) => x+y
    fn
  }

  var s =f(2)       // s 是一个函数
  var res = s(100)  // (y:Int) => 2+y
  println(res)      // 102
}

闭包 :

一个函数连同该函数的非局部变量的一个函数

def main(args: Array[String]): Unit = {
  // f是一个函数，它的返回值也是一个函数
  var f = (x: Int) => {
    // 对fn来说，x就是一个非局部变量。 x+fn 就会构成一个闭包结构
    var fn = (y: Int) => x + y
    fn
  }

  var s = f(2) // s 是一个函数
  var res = s(100) // 102
  var res1 = s(80) // 82
  println(res1)
}

部分应用函数 ：

定义多个参数而只调用一个参数

def fn(x:Int,y:Int,z:Int)={
    println(x,y,z)
    x*y*z
  }
  def main(args: Array[String]): Unit = {
    // rs: 部分应用函数
    // _: 占位符
    var rs = fn(2,3,_)
    println(rs(4))
  }
}

小结：定义函数的方式

标准方式： def 函数名()

字面量方式： var fn = () =>

柯里化方式： def fn(x:Int,y:Int,z:Int) => {} 把多个参数分开，一个一个写