8、高阶函数

普通函数

高阶函数：参数或返回值是函数

object a_基础 {
  def main(args: Array[String]): Unit = {
    println(mymax(1,2,math.max))

    println(myadd(1)(2))
  }

  def mymax(a:Int,b:Int,f:(Int,Int) => Int)={　　//f类型的映射即函数
    f(a,b)
  }

  def myadd(a:Int)={　　//返回值类型是函数，inner _ 表示函数本身
    def inner(b:Int)={
      a + b
    }
    inner _
  }
}

匿名函数

scala> arr.map((i:Int) => i*2:Int)　　//写明返回值类型
res24: Array[Int] = Array(2, 4)

scala> arr.map((i:Int) => i*2)　　　　//推断返回值类型
res25: Array[Int] = Array(2, 4)

scala> arr.map((i) => i*2)　　　　//类型推断
res29: Array[Int] = Array(2, 4)

scala> arr.map(i => i*2)　　　　//再简化
res30: Array[Int] = Array(2, 4)

scala> arr.map(_*2)　　//i就出现了一次，最终版
res32: Array[Int] = Array(2, 4)

柯里化

定义：将原来接受两个参数的函数变成新的接受一个参数的函数的过程。即柯里化后的函数返回以原来第二个参数作为参数的函数

scala> def add(a:Int,b:Int)=a+b　　//原函数
add: (a: Int, b: Int)Int^

scala> def add(a:Int)={b:Int => a + b}　　//柯里化
add: (a: Int)Int => Int

scala> add(1)(2)
res0: Int = 3

scala> def add(a:Int)(b:Int) =a + b　　//柯里化简化
add: (a: Int)(b: Int)Int

scala> add(3)(4)
res1: Int = 7

好处：将某个参数单独拎出来，以提供更多用于类型推断的信息

控制抽象

在scala中，一系列语句可组成不带参数也没有返回值的函数

object c_控制抽象 {
  def main(args: Array[String]): Unit = {
    runinthread(println(Thread.currentThread().getName()))
    runinthread(println(Thread.currentThread().getName()))
  }

  def runinthread(block: => Unit): Unit ={
    new Thread() {
      override def run(): Unit ={
        block
      }
    }.start()
  }

}