Scala-闭包、柯里化、递归、控制抽象、惰性加载

闭包

柯里化 

递归

控制抽象

惰性加载

---

闭包

闭包：如果一个函数，访问到了它的外部（局部）变量的值，那么这个函数和他所处的 环境，称为闭包

def A(a : Int): Int=>Int = {
      val b = 2
      def C(c : Int): Int = {
        a+b+c
      }
      //C函数作为返回值
      C
    }
    //最后输出就为1+2+3 的值
    println(A(1)(3))

//lambda表达式闭包的简写
    def ad(a : Int): Int => Int = a + _

柯里化 

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

def CL(a : Int)(b : Int): Int = {
      a + b
    }
    //输出两数和
    println(CL(1)(2))

递归

一个函数/方法在函数/方法体内又调用了本身，我们称之为递归调用

object fun {
  def main(args: Array[String]): Unit = {
    //使用递归来计算阶乘
    def fact(n : Int): Int ={
      if(n == 1) return 1
      n *fact(n - 1)
    }

    //尾递归优化实现
    def tail(n : Int): Int = {
      @tailrec
      def loop(n : Int, res : Int): Int = {
        if (n == 1) return res
        loop(n - 1, res * n)
      }
      loop(n,1)
    }
  }
}

控制抽象

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

名调用：把代码传递过去

object fun {
  def main(args: Array[String]): Unit = {
    //1、常规传值参数
    def f1(a : Int): Int = {
      println("a="+a)
      println("f1调用")
      1
    }

    //2、传名参数
    def f2(a: => Int): Unit = {
      println(a) //输出几次那么传入的函数就会被执行几次
      println(a)
    }
    f2(f1(2))
  }
}

 使用控制抽象实现自定义while循环功能：

object fun {
  def main(args: Array[String]): Unit = {
    //定义起始变量
    var n1 = 10

    //1、常规的while循环
    while (n1 >= 1){
      println(n1)
      n1 -= 1
    }

    var n2 = 10
    //2、用闭包实现函数，将代码块作为参数传入，递归调用
    def myWhile(con : => Boolean): (=> Unit) => Unit ={
      //内层函数需要递归调用，参数就是循环体
      def doLoop(op: =>Unit) : Unit = {
        if(con){
          op
          myWhile(con)(op)
        }
      }
      doLoop _
    }
    //调用实现 myWhile
    myWhile(n2 >= 1){
      println(n2)
      n2 -= 1
    }

    //3、用匿名函数实现
    var n3 = 10
    def myWhile2(con : => Boolean): (=> Unit) => Unit ={
      //内层函数需要递归调用，参数就是循环体
      op => {
        if(con){
          op
          myWhile2(con)(op)
        }
      }
    }
    //调用实现myWhile2
    myWhile2(n3 >= 1){
      println(n3)
      n3 -= 1
    }
    
    //4、柯里化实现
    def myWhile3(con : => Boolean)(op : =>Unit): Unit = {
      if(con){
        op
        myWhile3(con)(op)
      }
    }
  }
}

惰性加载

当函数返回值被声明为 lazy 时，函数的执行将被推迟，直到我们首次对此取值，该函 数才会执行。这种函数我们称之为惰性函数。

 lazy val  res : Int = sun(1,2)

    println("1函数调用")
    println("2打印res"+res)

    def sun(a: Int, b: Int): Int ={
      println("3、sum调用")
      a + b
    }

我们观察其输出顺序：