对scala函数总结

1.普通函数(有参函数、无参函数)

def fun (a: Int , b: Int ) : Unit = {
   println(a+b)
 }
fun(1,1)
    
def fun1 (a : Int , b : Int)= a+b
    println(fun1(1,2))  

2.递归函数：在函数体内调用自己本身

// 计算num的阶乘
def fun1(num:Int):Int = {
    if(num == 1||num == 0) 1
    else num * fun1(num - 1)
}

3.默认值的函数

 def fun2(num1:Int = 10,num2:Int = 20) = {
    num1 + num2
}
  
  def fun3(num1:Int,num2:Int = 20) = {
    num1 + num2
}
  
  def fun4(num1:Int=10,num2:Int) = {
    num1 + num2
}

4.可变参数个数的函数

def fun4(elements :Int*)={
      var sum = 0;
      for(elem <- elements){
        sum += elem
      }
      sum
}
    println(fun4(1,2,3,4))

5.匿名函数

var fun6 = (num1:Int,num2:Int) => num1+ num2

6.嵌套函数

def fun7(num:Int)={
      def fun8(a:Int,b:Int):Int={
        if(a == 1){
          b
        }else{
          fun8(a-1,a*b)
        }
      }
      fun8(num,1)
}

7.偏应用函数

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

 def log(date:Date,content:String) = {
    println("date:" + date + "\tcontent:" + content)
  }
  
  val date = new Date()
  log(date,"log1")
  log(date,"log2")
  log(date,"log3")
  println("==============================")
    
  val logBoundDate = log(date,_:String)
  logBoundDate("log11")
  logBoundDate("log12")
  logBoundDate("log13")

8.高阶函数

函数的参数是函数，或者函数的返回类型是函数，或者函数的参数和函数的返回类型都是函数的函数。

/**
   * 函数的参数是函数:
   * f1:(Int)=>Int  告诉要传入的函数的格式 
   * 把函数当成了对象穿来穿去、scala支持面向函数编程
   */
  def highFun1(f1:(Int)=>Int,num:Int) = {
    f1(num)
  }
  
  def tmpFun(num1:Int) = {
    num1+1000
  }
  
  /**
   * 函数的返回是函数
   * 函数无参数
   * 函数的返回个(Int,Int)=>Double格式的函数
   */
  def highFun2():(Int,Int)=>Double = {
    def tmpFun2(num1:Int,num2:Int):Double = {
      num1 + num2
    }
    tmpFun2
  }
  
  def highFun3():(Int,Int)=>Double = {
    (num1:Int,num2:Int)=>num1+num2
  }
  
   /**
    * 函数是参数是函数，返回也是函数
    * 这个函数也是高阶函数
    */
  def highFun4(f1:(Int,Int) => Int,num1:Int):(Int)=>Double = {
    val rest = f1(num1,1000)
    (num:Int) => num + 1
  }
  
  def highFun5(num:Int):(Int)=>Int = {
    def fun(a:Int)={
      num + a
    }
    fun
  }

9. 柯里化函数

可理解为对高阶函数的简化

def klhFun(a:Int)(b:Int) = a*b

Scala语言的简写规则：

函数的返回值类型可以省略，因为scala具备自动推测的功能，他会根据返回值的自动来决定这个函数的返回值类型
将你要返回的值放在函数的最后一行，那么这个值就会被自动返回
如果你的函数体内只有一个语句，可以将这行语句与函数名在一行。
总结：

对于递归函数 必须明确返回值类型，不然不知所措；
默认值的函数中，如果传入的参数个数与函数定义相同，则传入的数值会覆盖默认值；如果不想覆盖默认值，传入的参数个数小于定义的函数的参数，则需要指定参数名称；
在scala中+=前后的数值类型必须一致，+前后的数值类型可以不一致；
注意点：
1)匿名函数不能显示的声明返回值类型
2)匿名函数必须赋给一个变量、变量，通过变量来调用这个匿名函数
3)匿名函数的参数与函数体必须要用=>来关联