Scala学习(四)

1.闭包

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

    //闭包练习
    def sumX(x:Int)={
      def sumY(y:Int):Int={
        x+y
      }

      sumY _
    }

    val xResult = sumX(5)
    val result = xResult(6)
    println(result)

2.函数式编程递归和尾递归

2.1递归

嵌套调用自身的函数
必须要有停止的条件
递归调用的参数必须有规律
结果值的类型不能省略

    //使用递归实现阶乘
    def func_count(n:Int):Long={
      if(n==1)
        {
          1L
        }
        else
        {
          func_count(n-1)*n
        }
    }

    println(func_count(6))

2.2 尾递归

尾递归，顾名思义，即最后递归调用函数的一行，只有自身的函数没有其他的值。

    //使用尾递归对阶乘进行优化
    def lastRecursion(n:Int,res:Long=1):Long={
      if(n==1)
        {
          res
        }
        else
        {
          lastRecursion(n-1,res*n)
        }
    }

    val result = lastRecursion(5)
    println(result)

3.控制抽象

控制抽象分为值调用和名调用

3.1 值调用

值调用就是将代码块的结果作为参数传入到函数当中

    //控制抽象
    def sayHi(name:String)={
      println("函数调用")
      println(s"hi $name")
      println(s"hi $name")
    }

    sayHi({
      println("我是代码块")
      "mao"
    })

3.2 名调用

名调用不是将代码块的结果作为参数传入函数中，直接将整个代码块传入到参数中，使用一次代码块就会运行一次。

    def sayHi(name: =>String)={
      println("函数调用")
      println(s"hi $name")
      println(s"hi $name")
    }

    sayHi({
      println("我是代码块")
      "mao"
    })

4.惰性函数

惰性函数，当函数的返回值被声明为lazy的时候，函数的执行将被推迟到我们首次对此取值，该函数才会执行，这种函数我们称为惰性函数
案例实操：

//正常函数执行
    //实现懒加载
    def sumXY(x: Int, y: Int): Int = {
      println("sum函数调用")
      x + y
    }

    val sum: Int = sumXY(5, 6)
    println("其他代码")
    println(sum)

运行结果：

使用惰性函数运行上述代码,不会在调用函数的时候就执行，而是等到调用返回值的时候再进行计算

    lazy val sum: Int = sumXY(5,6)
    println("其他代码")
    println(sum)