1.3 Scala函数

1.Scala函数的定义

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

    def fun1 (a : Int , b : Int)= a+b
    println(fun1(1,2))

结果:

注意点：

• 函数定义语法 用def来定义
• 可以定义传入的参数，要指定传入参数的类型
• 方法可以写返回值的类型也可以不写，会自动推断，有时候不能省略，必须写，比如在递归函数中或者函数的返回值是函数类型的时候。
• scala中函数有返回值时，可以写return，也可以不写return，会把函数中最后一行当做结果返回。当写return时，必须要写函数的返回类型。
• 如果返回值可以一行搞定，可以将{}省略不写
• 如果省略掉 = 则函数自动将返回值丢弃掉。即我们一般可以在无返回值的函数中，省略掉=
• 传递给方法的参数可以在方法中使用，并且scala规定方法的传过来的参数为val的，不是var的。所以在函数中不可以修改参数值
• 如果去掉方法体前面的等号，那么这个方法返回类型必定是Unit的。这种说法无论方法体里面什么逻辑都成立，scala可以把任意类型转换为Unit.假设，里面的逻辑最后返回了一个string，那么这个返回值会被转换成Unit，并且值会被丢弃。
  
  

2.递归函数

  /**
     * 递归函数 
     * 5的阶乘
     */
    def fun2(num :Int) :Int= {
      if(num ==1)
        num
      else 
        num * fun2(num-1)
    }
    print(fun2(5))

结果:

3.包含参数默认值的函数

    def f2(a:Int=5,b:Int=10)={
      a+b
    }
      println(f2(b=100))
      //println(f2(20)) 这里不写参数名视为第一个参数也就是a

结果:

4.可变参数个数的函数

    /**
      * 可变参数个数的函数
      * 注意：多个参数逗号分开
      */
    def fun(elements: Int*)={
      var sum = 0;
      for (elem <- elements){
        sum += elem
      }
      sum
    }
    println(fun(1,2,3,4,5))

结果:

5.匿名函数

1. 有参匿名函数
2. 无参匿名函数
3. 有返回值的匿名函数

• 可以将匿名函数返回给val定义的值
• 匿名函数不能显式声明函数的返回类型

    /**
      * 匿名函数
      * 1.有参数匿名函数
      * 2.无参数匿名函数
      * 3.有返回值的匿名函数
      * 注意：
      * 可以将匿名函数返回给定义的一个变量
      */
    //有参数匿名函数
    val value1 =(a:Int) => {
      println(a)
    }
    value1(1)
    //无参数匿名函数
    val value2 = ()=>{
      println("啦啦啦啦啦")
    }
    value2()
    //有返回值的匿名函数
    val value3 = (a:Int,b:Int) =>{
      a+b
    }
    println(value3(4,4))

结果:

注意:调用匿名函数时 () 不能省略

6.嵌套函数

/**
  * 嵌套函数
  * 例如：嵌套函数求5的阶乘
  */
def fun5(num:Int)={
  def fun6(a:Int,b:Int):Int={
    if(a == 1){
      b
    }else{
      fun6(a-1,a*b)
    }
  }
  fun6(num,1)
}
println(fun5(5))

结果:

7.偏应用函数

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

    /**
      * 偏应用函数
      */
    def log(date :Date, log :String)= {
      println("date is "+ date +",log is "+ log)
    }

    val date = new Date()
    log(date ,"log1")
    log(date ,"log2")
    log(date ,"log3")

    //想要调用log，以上变化的是第二个参数，可以用偏应用函数处理
    val logWithDate = log(date,_:String)
    logWithDate("log11")
    logWithDate("log22")
    logWithDate("log33")

结果:

对传参进行简化

8.高阶函数

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

• 函数的参数是函数
• 函数的返回是函数
• 函数的参数和函数的返回是函数

    /**
      * 高阶函数
      * 函数的参数是函数		或者函数的返回是函数		或者函数的参数和返回都是函数
      */

    //函数的参数是函数
    def hightFun(f : (Int,Int) =>Int, a:Int ) : Int = {
      f(a,100)
    }
    def f(v1 :Int,v2: Int):Int  = {
      v1+v2
    }

    println(hightFun(f, 1))

    //函数的返回是函数
    //1，2,3,4相加
    def hightFun2(a : Int,b:Int) : (Int,Int)=>Int = {
      def f2 (v1: Int,v2:Int) :Int = {
        v1+v2+a+b
      }
      f2
    }
    println(hightFun2(1,2)(3,4))

    //函数的参数是函数，函数的返回是函数
    def hightFun3(f : (Int ,Int) => Int) : (Int,Int) => Int = {
      f
    }
    println(hightFun3(f)(100,200))
    println(hightFun3((a,b) =>{a+b})(200,200))
    //以上这句话还可以写成这样
    //如果函数的参数在方法体中只使用了一次 那么可以写成_表示
    println(hightFun3(_+_)(200,200))

结果:

9.柯里化函数

• 可以理解为高阶函数的简化

 /**
     * 柯里化函数
     */
    def fun7(a :Int,b:Int)(c:Int,d:Int) = {
      a+b+c+d
    }
    println(fun7(1,2)(3,4))

结果:

来源：CSDN

作者：BF-LoneSilverWind

链接：https://blog.csdn.net/digua930126/article/details/103673417