2、scala函数

1、函数定义
　　def：关键字
　　fun1：函数名
　　x1：参数名
　　Int：类型名
　　冒号后面Int：返回值类型
　　{}：函数体

// 完整版函数
def fun1(x1:Int, x2:Int):Int = {
  return x1 + x2
}
println(fun1(1, 2))

// 简化版，最后一行语句的执行结果就是这个函数的返回值
def fun1_01(x1:Int, x2:Int) = {
  x1 + x2
}
println(fun1_01(1, 2))

2、一些普通函数
2.1、带有默认值的函数：函数中参数的默认修饰符是val，不能再对他重新赋值

def fun2(a:Int, b:Int=10) = {
  a + b
}
println(fun2(1))

2.2、可变参数长度的函数

def fun3(elems:Int*) = {
  for(elem <- elems) {
    println(elem)
  }
}
fun3(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

2.3、递归函数：必须要有返回值类型，否则 num * fun4(num - 1) 无法推测返回值类型

def fun4(num:Int):Int = {
  if(num == 1) {
    1
  } else {
    num * fun4(num - 1)
  }
}
println(fun4(5))

2.4、匿名函数：返回值可以赋给一个变量，跟函数体之间用 => 连接
匿名函数简化：匿名函数中参数在函数体中只出现一次可以用_代替

var fun5 = (name:String, facePower:Double) => {
  println(name + " facePower:" + facePower)
}
fun5("liushishi", 100.0)

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

// 普通函数
def fun6(date:Date, log:String) {
  println(date + " " + log)
}
var date2 = new Date();
fun6(date2, "log1")
fun6(date2, "log2")
// 偏应用函数是一种表达式，不需要提供函数需要的所有参数，只需要提供部分，或不提供所需参数
val logWithDate = fun6(date2, _:String)
logWithDate("log3")
logWithDate("log4")

val log5 = "log5"
val logWithDate2 = fun6(_:Date, log5)
logWithDate2(new Date())
logWithDate2(new Date())

3、高阶函数

//高阶函数
def fun7(fun8:(Int, Int) => Int): Int = {
  fun8(100, 200)
}
// fun7需要一个函数作为参数，于是自定义一个fun9，传给fun7
def fun9(a:Int, b:Int) = {
  a + b
}
println(fun7(fun9))
// 传给fun7一个匿名函数
println(fun7((a:Int, b:Int) => {
  a + b
}))
// 匿名函数简化版：匿名函数中参数在函数体中支出现一次可以用_代替
// 相当于 (a:Int, b:Int) => {a + b} 被改写为 (_+_)
println(fun7((_+_)))

4、柯里化函数：实际上是高阶函数的简化版

// 高阶函数完整版
def fun1(param1:Int):(Int)=>Int = {
  def fun2(param2:Int):Int = {
    param1 + param2
  }
  fun2
}
// 柯里化函数
def fun3(param1:Int)(param2:Int):Int = {
  param1 + param2
}
println(fun1(1)(2))
println(fun3(1)(2))

5、扩展
repl(read evaluate print loop) 交互解释器