Scala的函数进阶

1.函数字面量语法：

（参数列表）=> {方法体} 在字面量中，部分可以省略，代码如下：

def main(args: Array[String]): Unit = {
    //字面量
   //教室310+教室309
    println("教室310")//字面量
    var classRoom="教室310"//字面量

    //定义函数的方式1
    def sum(x:Int,y:Int)  ={
      x+y
    }
    println(sum(100,200))
    //定义函数的方式2，函数字面量
    var sum1=(x:Int,y:Int) => {x+y}
    //简写1，省略{}
    var sum2=(x:Int,y:Int) => x+y
    //简写2，用_占位符，(Int,Int)=>Int 它表示一种类型，收到两个整型的参数，返回一个整型值
    var sum3:(Int,Int) =>Int = _ + _
    //调用一个函数
    println(sum1(100,200))
  }
}

2.scala函数的闭包，闭包=函数+非局部变量

特点：保持引用

作用：一个函数连同该函数的非局部变量的一个引用环境

用代码解释如下：奶茶店和咖啡店相当于函数，美团相当于非局部变量

//写一个函数，它的返回值是一个函数
 // def main(args: Array[String]): Unit = {
   // var f = (x:Int) => {
   //   var t =(y:Int) => x+y
      //t是一个函数
      //x就是一个非局部变量
     // t
      //闭包=函数+非局部变量
      //特点：保持引用
  //  }
   // var s =f(100)//s:(y:Int)=>100+y
   // var res =s(200) //300
   // var res1=s(300) //300
  //  println(res,res1)
 // }
//}
 def main(args: Array[String]): Unit = {
    //奶茶店1
    var add = (x:Int,y:Int) => x + y
    //咖啡店1
    var mul= (x:Int,y:Int) => x * y
    //定义一个函数，它的特点是：第一个参数的类型是函数
    //美团
    var op=(fn:(Int,Int)=>Int,a:Int,b:Int) =>{
      fn(a,b)
    }
    add(100,200)
    println(op(add,100,200))
    println(op(mul,100,200))
  }
}

3.scala的函数柯里化

柯里化定义的语法为：

def 函数名 (参数列表1) (参数列表2).....(参数列表n):type = {
    方法体
}

柯里化的应用：

def main(args: Array[String]): Unit = {
//    def add(x:Int,y:Int)=x+y
//    println(add(100,300))
    //柯里化的方式，定义一个函数
   def add(x:Int)(y:Int)(z:Int)=x+y+z
    //调用
    println(add(100)(300)_)
    println(add(100)(200)(300))//直接给三个参数
    var t=add(100)(300)_//表示一个占位符。先算有两个参数的情况，结果是一个函数
    println(t(200))//传入最后一个参数，就能计算结果了
  }
}

4.scala部分应用函数：如果一个函数包含多个参数，对该函数传递部分参数使得该函数返回一个函数

def main(args: Array[String]): Unit = {
    def mul(x:Int,y:Int,z:Int):Int ={
      println(s"x=$x,y=$y,z=$z")
      x*y*z
    }
    //println(mul(10,2,3))
    //f是:部分函数
    //_是:部分函数
    var f=mul(10,2,_)
    println(f(3))
  }
}