1.1 高阶函数

1.函数可以作为值进行传递

// 函数的返回值作为参数进行传递
object Test03_Demo {
  def main(args: Array[String]): Unit = {
    val f = foo()
    println(f)
  }
  def foo():String = {
    "test"
  } 
}
 //下划线 _ 将函数当成一个整体传递给变量
object Test03_Demo {
  def main(args: Array[String]): Unit = {
    val f2 = foo _
    println(f2())
  }
  def foo():String = {
    "test"
  }
}
//如果变量明确类型，函数可以直接赋值给变量
object Test03_Demo {
  def main(args: Array[String]): Unit = {
    val f3:()=>String = foo
    println(f3)
  }
  def foo():String = {
    "test"
  }
}

2.函数可以作为参数进行传递

object Test04_Demo {
  def main(args: Array[String]): Unit = {
   def f1(a:Int,b:Int,f:(Int,Int)=>Int):Int ={
     f(a,b)
   }
    println(f1(3,2, (c, d) => {
      c + d
    }))
  }
}

3.函数可以作为函数返回值返回

object Test05_Demo {
  def main(args: Array[String]): Unit = {
   def f1():() => String={
     def f2()={
       "f2"
     }
     f2
   }
    val str :()=> String = f1()
    println(str())
  }
}

1.2 匿名函数

1.没有名字的函数就是匿名函数

（x：Int）=> { 函数体 }
x => { 函数体 }

1.3 函数柯里化 & 闭包

闭包：一个内部函数，访问了外部函数的局部变量，那么这个函数和他所处的环境，称为闭包

def f1()={
  var a = 10
  def f2(b:Int)={
    a+b
  }
  f2 _
}
//在调用时，f1函数执行完毕后，局部变量a应该随着栈空间释放掉
val f = f1()
//但是此处，变量a其实并没有释放，而是包含在了f2函数内部，形成了闭合的效果
println(f(3))

函数柯里化：把一个参数列表的多个参数，变成多个参数列表

// 函数柯里化一定存在闭包
def f3()(b:Int) = {
  2+b
}
println(f3()(3))

1.4 递归

def ti(n : Int):Int = {
       if ( n == 1 || n == 0){
          1
       }
      return (n-1)+(n-2)
    }
println(ti(1))

1.5 控制抽象

值调用：把计算后的值传递过去

def f = () => {
  10
}
foo(f())
def foo(a:Int)={
  println(a)
}

名调用：把代码传递过去

def f = ()=>{
  println("f....")
  10
}
def ff(f1: =>Int): Unit ={
  println(f1)
  println(f1)
}
ff(f())

1.6 懒加载

函数的返回值由一个变量接收，被lazy修饰 当第一次用到的时候 函数才会被执行

def add(a:Int, b:Int):Int{
  a+b
}
lazy val res = add(1,2)
println(val)//此时才会调用add

1.7 总结

柯里化&闭包 自制while循环

   var  a = 10
   while (a > 0){
      println(a)
      a -= 1
    }

    def mywhile(condition: =>Boolean) :(=>Unit)=>Unit={
      def doloop(op: => Unit): Unit={
        if(condition){
          op
          mywhile(condition)(op)
        }
      }
      doloop _
    }
    var a = 9
    mywhile(a > 0){  //因为是代码块所以可以省略 括号
      println(a)
      a -= 1
    }