5.函数式编程

第 5 章 函数式编程

​ 面向对象和面向过程都属于同一类，命令式编程，函数式编程和命令式编程是整体完全不同的思路，命令式编程指的是不管你是拆解对象也好，还是直接按照步骤，按照过程把程序定义好。我们最终落脚点都是计算机具体执行程序的具体命令。函数式编程并不管计算机底层是怎么处理这件事，最关心的是我们整个数据的映射关系是什么样的。
之前的命令式编程不管是面向对象还是面向过程，在做编程设计的时候，我们用到的那些语法，都是面向计算机硬件的抽象，比如在java或者C中，定义一个变量，这个变量是什么概念呢， int a =1; 并不是数学意义上的 a=1;因为数学上a=1;那接下来a和1完全就是等价的关系，而在计算机编程中a=1;之后还可以a=2;还可以在改变他的值，这在数学上是完全不可思议的事情。所以这个a并不是数学意义上的a，是一个变量，对应的是计算机底层的一块内存空间。所以a=1,对应的是计算机底层把一条数据写入到对应的内存空间的一条指令。所以后面再给a赋别的值就是更改内存空间中的数据。所以命令式编程的每一行代码，都能翻译成对应的计算机指令。譬如 if控制语句 for循环都能转换成计算机底层的跳转指令。这对于计算机来讲就是最友好，最容易理解的语言。

​ 但是从另外一方面讲 对于人来说，这可能并不是特别好理，(假如是一个编程小白，没有计算机相关知识，看到这样的表达式就非常的困惑，我们学过数学，但是这里面的等号和数学上的完全不一样，这里面的a也不是数学上的未知数，变量的概念和数学也完全不一样。所以看到这样一种代码可能需要非常清楚编程语言或者计算机底层的逻辑才能把他理解透彻)所以先对应的函数式编程就相当于一道数学题的求解。所以真正的函数式编程语言中，是没有变量的，所有的值来了之后都是常量，都是一个值，a是1他就是1不会在改了。所以在Scala中推荐大家能用常量val的地方就用val，这也是符合函数式编程思想的。把这个定义好之后呢，求解问题，计算的过程就是不停的表达式求值的过程，可能一开始有个a 有个方程要求里面的未知数，未知数相当于一个表达式，我们就是一直再求表达式的值，而且在函数式编程中，每一段程序都有返回值，if else 条件控制 条件分支控制，或者是for循环都有一个返回值，所以真正的函数式编程里面，本质就是一个映射关系，表达式不停的求值，然后做函数的映射关系，不停的y=f(x)，不停的给它做转换，这就是函数式编程的本质。所以函数式编程对于大家没有掌握编程的，掌握了数学来讲是更好理解的一种编程方式，并不关心计算机底层的实现，对人更加的友好， 当然与之对应的，对于计算机来讲就不是那么好理解了，所以他的编译器可能要非常的复杂，可能要做非常多额外的操作，才能把他翻译成计算机可以理解的内容。
​ 那对于这两种特性所带来的两种编程范式，命令式编程对计算机来讲更好理解，执行起来效率更高，函数式编程对于人更好理解，执行效率低，但是程序员上手的难度比较低，直接就可以看着代码写出自己的代码，而且在编程过程中可以专注于业务逻辑，不需要考虑过多的计算机底层的处理规则这就是他们最大的区别。
​ Scala中为什么要借鉴这样的编程范式编程思路呢，一方面Scala设计的时候希望他能是一个更好的语言，能够对于程序员来讲编程效率更高的语言，另一方面，函数式编程有非常好的特性，我们定义出来一个函数之后，其实他的功能就是确定的，函数式编程是拥有不可变性的，比如我们定义一个y = x*x 定义了一个函数，其中的x是可以变化的，对应一个函数的输入参数，对着这个函数而言你可以任意的输入参数，但是只要你输入的是同一个参数比如10 得到的结果永远都是100，对于函数而已他是不可变的，得到的结果都是确定性的，这在函数的处理过程中就可以把他进行分布式的并行处理了，大家自然就想到了，在大数据的场景下，我们一台机器如果处理不过来数据量很大，那就要做一个集群风分布式处理，如果在处理的过程中拥有不可变性，没有变量，所有的值不会受外界的影响，那就可以分布在不同的机器上运行，最后得到的结果汇总即可，彼此直接没有额外的影响，这就是我们说的函数式编程没有副作用的，他特别适合用在大数据处理的分布式处理环境内，提高并行能力的时候使用函数式编程就非常好用，所以Scala1就借鉴了函数式编程的特点，可以说是一门函数式编程语言，所以呢在大数据处理过程当中，经常提到的大数据核心的处理框架Spark底层就用Scala来编写 另外用于构建高并发分布式应用的工具包 azzk底层也是Scala写的当然还有很多耳闻能闲的工具 比如消息队列Kafka底层也是Scala，所以大家会发现这样一种函数式编程的特性再结合了Java一些面对对象的特点，基于JVM可移植性强的特点，最终导致Scala特别容易应用在大数据的应用环境中。这就是函数式编程思想的应用，以及Scala特点的说明，Scala是一门面对对象的语言，同时也是一门函数式编程语言。

1）面向对象编程

• 解决问题，分解对象，行为，属性，然后通过对象的关系以及行为的调用来解决问题。

• 对象：用户

• 行为：登录、连接 JDBC、读取数据库

• 属性：用户名、密码

Scala 语言是一个完全面向对象编程语言。万物皆对象

对象的本质：对数据和行为的一个封装

2）函数式编程

解决问题时，将问题分解成一个一个的步骤，将每个步骤进行封装（函数），通过调用这些封装好的步骤，解决问题。

例如：请求->用户名、密码->连接 JDBC->读取数据库

• Scala 语言是一个完全函数式编程语言。万物皆函数。

• 函数的本质：函数可以当做一个值进行传递

• 在 Scala 中函数式编程和面向对象编程完美融合在一起了。

5.1 函数基础

5.1.1函数基本语法

1）基本语法

2）案例实操

需求：定义一个函数，实现将传入的名称打印出来。

object TestFunction {
def main(args: Array[String]): Unit = {
    // （1）函数定义
   def f(arg: String): Unit = {
       println(arg)
    }
      // （2）函数调用
      // 函数名（参数）
      f("hello world")
  }
}

5.1.2 函数和方法的区别

1）核心概念

• 为完成某一功能的程序语句的集合，称为函数。

• 类中的函数称之方法。

2）案例实操

• Scala 语言可以在任何的语法结构中声明任何的语法

• Scala 中函数可以嵌套定义

package chapter05

object Test01_FunctionAndMethod {
  def main(args: Array[String]): Unit = {
    // 定义函数
    def sayHi(name: String): Unit = {
      println("hi, " + name)
    }

    // 调用函数
    sayHi("alice")

    // 调用对象方法
    Test01_FunctionAndMethod.sayHi("bob")

    // 获取方法返回值
    val result = Test01_FunctionAndMethod.sayHello("cary")
    println(result)
  }

  // 定义对象的方法
  def sayHi(name: String): Unit = {
    println("Hi, " + name)
  }

  def sayHello(name: String): String = {
    println("Hello, " + name)
    return "Hello"
  }
}

5.1.3 函数定义

1）函数定义

• 函数 1：无参，无返回值

• 函数 2：无参，有返回值

• 函数 3：有参，无返回值

• 函数 4：有参，有返回值

• 函数 5：多参，无返回值

• 函数 6：多参，有返回值

2）案例实操

object Test02_FunctionDefine {
  def main(args: Array[String]): Unit = {
    //    （1）函数1：无参，无返回值
    def f1(): Unit = {
      println("1. 无参，无返回值")
    }
    f1()
    println(f1())

    println("=========================")

    //    （2）函数2：无参，有返回值
    def f2(): Int = {
      println("2. 无参，有返回值")
      return 12
    }
    println(f2())

    println("=========================")

    //    （3）函数3：有参，无返回值
    def f3(name: String): Unit = {
      println("3：有参，无返回值 " + name)
    }

    println(f3("alice"))

    println("=========================")

    //    （4）函数4：有参，有返回值
    def f4(name: String): String = {
      println("4：有参，有返回值 " + name)
      return "hi, " + name
    }

    println(f4("alice"))

    println("=========================")

    //    （5）函数5：多参，无返回值
    def f5(name1: String, name2: String): Unit = {
      println("5：多参，无返回值")
      println(s"${name1}和${name2}都是我的好朋友")
    }

    f5("alice","bob")

    println("=========================")

    //    （6）函数6：多参，有返回值
    def f6(a: Int, b: Int): Int = {
      println("6：多参，有返回值")
      return a + b
    }

    println(f6(12, 37))
  }
}

5.1.4 函数参数

1）案例实操

（1）可变参数

（2）如果参数列表中存在多个参数，那么可变参数一般放置在最后

（3）参数默认值，一般将有默认值的参数放置在参数列表的后面

（4）带名参数

2）案例实操

object Test03_FunctionParameter {
  def main(args: Array[String]): Unit = {
    //    （1）可变参数
    def f1(str: String*): Unit = {
      println(str)
    }

    f1("alice")
    f1("aaa", "bbb", "ccc")

    //    （2）如果参数列表中存在多个参数，那么可变参数一般放置在最后
    def f2(str1: String, str2: String*): Unit = {
      println("str1: " + str1 + " str2: " + str2)
    }
    f2("alice")
    f2("aaa", "bbb", "ccc")

    //    （3）参数默认值，一般将有默认值的参数放置在参数列表的后面
    def f3(name: String = "atguigu"): Unit = {
      println("My school is " + name)
    }

    f3("school")
    f3()

    //    （4）带名参数
    def f4(name: String = "atguigu", age: Int): Unit = {
      println(s"${age}岁的${name}在尚硅谷学习")
    }

    f4("alice", 20)
    f4(age = 23, name = "bob")
    f4(age = 21)
  }
}

5.1.5 函数至简原则（重点）

函数至简原则：能省则省

1）至简原则细节

（1）return 可以省略，Scala 会使用函数体的最后一行代码作为返回值

（2）如果函数体只有一行代码，可以省略花括号

（3）返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）

（4）如果有 return，则不能省略返回值类型，必须指定

（5）如果函数明确声明 unit，那么即使函数体中使用 return 关键字也不起作用

（6）Scala 如果期望是无返回值类型，可以省略等号

（7）如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加

（8）如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略

（9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略

2）案例实操

package chapter05

// 函数至简原则
object Test04_Simplify {
  def main(args: Array[String]): Unit = {

    def f0(name: String): String = {
      return name
    }

    println(f0("atguigu"))

    println("==========================")

    //    （1）return可以省略，Scala会使用函数体的最后一行代码作为返回值
    def f1(name: String): String = {
      name
    }
    println(f1("atguigu"))

    println("==========================")

    //    （2）如果函数体只有一行代码，可以省略花括号
    def f2(name: String): String = name
    println(f2("atguigu"))

    println("==========================")

    //    （3）返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）
    def f3(name: String) = name
    println(f3("atguigu"))

    println("==========================")

    //    （4）如果有return，则不能省略返回值类型，必须指定
//    def f4(name: String) = {
//      return name
//    }
//
//    println(f4("atguigu"))

    println("==========================")

    //    （5）如果函数明确声明unit，那么即使函数体中使用return关键字也不起作用
    def f5(name: String): Unit = {
      return name
    }

    println(f5("atguigu"))

    println("==========================")

    //    （6）Scala如果期望是无返回值类型，可以省略等号
     // 这种场景下，有时候把这种形式叫做过程，这就不是数学上得映射关系了，没有返回值，
      // 相当于定义了一个计算机要执行的子过程。一一行一行执行里面的代码即可，所以叫做过程
    def f6(name: String) {
      println(name)
    }

    println(f6("atguigu"))

    println("==========================")

    //    （7）如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加
    def f7(): Unit = {
      println("atguigu")
    }

    f7()
    f7

    println("==========================")

    //    （8）如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略
    def f8: Unit = {
      println("atguigu")
    }

//    f8()
    f8

    println("==========================")

    //    （9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略
    def f9(name: String): Unit = {
      println(name)
    }

    // 匿名函数，lambda表达式
    (name: String) => { println(name) }

    println("==========================")

  }
}

5.2 函数高级

5.2.1 匿名函数

1）说明

没有名字的函数就是匿名函数。

(x:Int)=>{函数体}

x：表示输入参数类型；Int：表示输入参数类型；函数体：表示具体代码逻辑

2）案例实操

需求 1：传递的函数有一个参数

传递匿名函数至简原则：

（1）参数的类型可以省略，会根据形参进行自动的推导

（2）类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过 1 的永远不能省略圆括号。

（3）匿名函数如果只有一行，则大括号也可以省略

（4）如果参数只出现一次，则参数省略且后面参数可以用_代替

object Test05_Lambda {
  def main(args: Array[String]): Unit = {
    val fun = (name: String) => {
      println(name)
    }
    fun("atguigu")

    println("========================")

    // 定义一个函数，以函数作为参数输入
    def f(func: String => Unit): Unit = {
      func("atguigu")
    }

    f(fun)
    f((name: String) => {
      println(name)
    })

    println("========================")

    // 匿名函数的简化原则
    //    （1）参数的类型可以省略，会根据形参进行自动的推导
    f((name) => {
      println(name)
    })

    //    （2）类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过1的永远不能省略圆括号。
    f( name => {
      println(name)
    })

    //    （3）匿名函数如果只有一行，则大括号也可以省略
    f( name => println(name) )

    //    （4）如果参数只出现一次，则参数省略且后面参数可以用_代替
    f( println(_) )

    //     (5) 如果可以推断出，当前传入的println是一个函数体，而不是调用语句，可以直接省略下划线
    f( println )

}

需求 2：实际示例，定义一个”二元运算“函数，只操作1和2两个数，但是具体运算通过参数传入

def dualFunctionOneAndTwo(fun: (Int, Int)=>Int): Int = {
  fun(1, 2)
}
val add = (a: Int, b: Int) => a + b
val minus = (a: Int, b: Int) => a - b
println(dualFunctionOneAndTwo(add))
println(dualFunctionOneAndTwo(minus))
// 匿名函数简化
println(dualFunctionOneAndTwo((a: Int, b: Int) => a + b))
println(dualFunctionOneAndTwo((a: Int, b: Int) => a - b))
println(dualFunctionOneAndTwo((a, b) => a + b))
println(dualFunctionOneAndTwo( _ + _))
println(dualFunctionOneAndTwo( _ - _))
println(dualFunctionOneAndTwo((a, b) => b - a))
println(dualFunctionOneAndTwo( -_ + _))

5.2.2 高阶函数

在 Scala 中，函数是一等公民。怎么体现的呢？

对于一个函数我们可以：定义函数、调用函数

函数作为值传递

    def f(n: Int): Int = {
      println("f调用")
      n + 1
    }


    val result: Int = f(123)
    println(result)

    // 1. 函数作为值进行传递
    val f1: Int=>Int = f
    val f2 = f _

    println(f1)
    println(f1(12))
    println(f2)
    println(f2(35))

// 结果
f调用
124
chapter05.Test06_HighOrderFunction$$$Lambda$5/2096171631@6debcae2
f调用
13
chapter05.Test06_HighOrderFunction$$$Lambda$6/2114694065@5ba23b66
f调用
36

def fun(): Int = {
  println("fun调用")
  1
}
val f3: ()=>Int = fun
val f4 = fun _
println(f3)
println(f4)

// 结果
chapter05.Test06_HighOrderFunction$$$Lambda$7/2101440631@35bbe5e8
chapter05.Test06_HighOrderFunction$$$Lambda$8/2109957412@2c8d66b2

函数作为参数传递

// 2. 函数作为参数进行传递
// 定义二元计算函数
def dualEval(op: (Int, Int)=>Int, a: Int, b: Int): Int = {
  op(a, b)
}
def add(a: Int, b: Int): Int = {
  a + b
}
println(dualEval(add, 12, 35))
println(dualEval((a, b) => a + b, 12, 35))
println(dualEval(_ + _, 12, 35))

函数作为返回值

    // 3. 函数作为函数的返回值返回
    def f5(): Int=>Unit = {
      def f6(a: Int): Unit = {
        println("f6调用 " + a)
      }
      f6    // 将函数直接返回
    }

//    val f6 = f5()
//    println(f6)
//    println(f6(25))

    println(f5()(25))

5.2.3 高阶函数案例

object Test07_Practice_CollectionOperation {
  def main(args: Array[String]): Unit = {
    val arr: Array[Int] = Array(12, 45, 75, 98)

    // 对数组进行处理，将操作抽象出来，处理完毕之后的结果返回一个新的数组
    def arrayOperation(array: Array[Int], op: Int=>Int): Array[Int] = {
      for (elem <- array) yield op(elem)
    }

    // 定义一个加一操作
    def addOne(elem: Int): Int = {
      elem + 1
    }

    // 调用函数
    val newArray: Array[Int] = arrayOperation(arr, addOne)

    println(newArray.mkString(","))

    // 传入匿名函数，实现元素翻倍
    val newArray2 = arrayOperation(arr, _ * 2)
    println(newArray2.mkString(", "))
  }
}

练习 1：定义一个匿名函数，并将它作为值赋给变量 fun。函数有三个参数，类型分别为 Int，String，Char，返回值类型为Boolean。

要求调用函数 fun(0, “”, ‘0’)得到返回值为 false，其它情况均返回 true。

// 1. 练习1
val fun = (i: Int, s: String, c: Char) => {
  if (i == 0 && s == "" && c == '0') false else true
}

println(fun(0, "", '0'))
println(fun(0, "", '1'))
println(fun(23, "", '0'))
println(fun(0, "hello", '0'))

练习 2： 定义一个函数 func，它接收一个 Int 类型的参数，返回一个函数（记作 f1）。它返回的函数 f1，接收一个 String 类型的参数，同样返回一个函数（记作 f2）。函数 f2 接收一个 Char 类型的参数，返回一个Boolean 的值。

要求调用函数 func(0) (“”) (‘0’)得到返回值为 false，其它情况均返回 true。

object Test08_Practice {
  def main(args: Array[String]): Unit = {

    // 2. 练习2
    def func(i: Int): String=>(Char=>Boolean) = {
      def f1(s: String): Char=>Boolean = {
        def f2(c: Char): Boolean = {
          if (i == 0 && s == "" && c == '0') false else true
        }
        f2
      }
      f1
    }

    println(func(0)("")('0'))
    println(func(0)("")('1'))
    println(func(23)("")('0'))
    println(func(0)("hello")('0'))

    // 匿名函数简写
    def func1(i: Int): String=>(Char=>Boolean) = {
      s => c => if (i == 0 && s == "" && c == '0') false else true
    }

    println(func1(0)("")('0'))
    println(func1(0)("")('1'))
    println(func1(23)("")('0'))
    println(func1(0)("hello")('0'))

    // 柯里化
    def func2(i: Int)(s: String)(c: Char): Boolean = {
      if (i == 0 && s == "" && c == '0') false else true
    }
    println(func2(0)("")('0'))
    println(func2(0)("")('1'))
    println(func2(23)("")('0'))
    println(func2(0)("hello")('0'))
  }
}  

5.2.4 函数柯里化&闭包

闭包：函数式编程的标配

1） 说明

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

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

2） 案例实操

（1）闭包

object Test09_ClosureAndCurrying {
  def main(args: Array[String]): Unit = {
      //定义一个两数求和的案例，通用性很强，但是适用性差，即每次都需要传入两个数
      //如果是200数相加 2w数的话每次都需要传这么多
    def add(a: Int, b: Int): Int = {
      a + b
    }

    // 1. 考虑固定一个加数的场景
    def addByFour(b: Int): Int = {
      4 + b
    }

    // 2. 扩展固定加数改变的情况
    //这里适用性的确强了，但是通行性不高，每次都需要定义一个函数来
    def addByFive(b: Int): Int = {
      5 + b
    }

    // 3. 将固定加数作为另一个参数传入，但是是作为”第一层参数“传入
    def addByFour1(): Int=>Int = {
      val a = 4
      def addB(b: Int): Int = {
        a + b
      }
      addB
    }

    def addByA(a: Int): Int=>Int = {
      def addB(b: Int): Int = {
        a + b
      }
      addB
    }

    println(addByA(35)(24))

    val addByFour2 = addByA(4)
    val addByFive2 = addByA(5)

    println(addByFour2(13))
    println(addByFive2(25))

    // 4. lambda表达式简写
    def addByA1(a: Int): Int=>Int = {
      (b: Int) => {
        a + b
      }
    }
    def addByA2(a: Int): Int=>Int = {
      b => a + b
    }

    def addByA3(a: Int): Int=>Int = a + _
    val addByFour3 = addByA3(4)
    val addByFive3 = addByA3(5)

    println(addByFour3(13))
    println(addByFive3(25))

}

（2）柯里化

// haskell 是最为有名最为纯粹的函数式编程语言
//scala之父说过 scala 是通向haskell的一个上瘾的药

// 5. 柯里化  
def addCurrying(a: Int)(b: Int): Int = {
  a + b
}
println(addCurrying(35)(24))

5.2.5 递归

1） 说明

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

2） 案例实操

import scala.annotation.tailrec

object Test10_Recursion {
  def main(args: Array[String]): Unit = {
    println(fact(5))
    println(tailFact(5))
  }

  // 递归实现计算阶乘
  def fact(n: Int): Int = {
    if (n == 0) return 1
    fact(n - 1) * n
  }

  // 尾递归实现
  def tailFact(n: Int): Int = {
    @tailrec
    def loop(n: Int, currRes: Int): Int = {
      if (n == 0) return currRes
      loop(n - 1, currRes * n)
    }
    loop(n, 1)
  }
}

5.2.6 控制抽象

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

// 1. 传值参数
def f0(a: Int): Unit = {
  println("a: " + a)
  println("a: " + a)
}
f0(23)
def f1(): Int = {
  println("f1调用")
  12
}
f0(f1())

a: 23
a: 23

f1调用
a: 12
a: 12

2） 名调用：把代码传递过去

def f1(): Int = {
  println("f1调用")
  12
}

// 2. 传名参数，传递的不再是具体的值，而是代码块
 def f2(a: =>Int): Unit = {
   println("a: " + a)
   println("a: " + a)
 }
 f2(23)
 f2(f1())
 f2({
   println("这是一个代码块")
   29
 })

a: 23
a: 23

f1调用
a: 12
f1调用
a: 12

这是一个代码块
a: 29
这是一个代码块
a: 29

3） 案例实操

object Test12_MyWhile {
  def main(args: Array[String]): Unit = {
    var n = 10

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

    // 2. 用闭包实现一个函数，将代码块作为参数传入，递归调用
    def myWhile(condition: =>Boolean): (=>Unit)=>Unit = {
      // 内层函数需要递归调用，参数就是循环体
      def doLoop(op: =>Unit): Unit = {
        if (condition){
          op
          myWhile(condition)(op)
        }
      }
      doLoop _
    }

    println("=================")
    n = 10
    myWhile(n >= 1){
      println(n)
      n -= 1
    }

    // 3. 用匿名函数实现
    def myWhile2(condition: =>Boolean): (=>Unit)=>Unit = {
      // 内层函数需要递归调用，参数就是循环体
      op => {
        if (condition){
          op
          myWhile2(condition)(op)
        }
      }
    }
    println("=================")
    n = 10
    myWhile2(n >= 1){
      println(n)
      n -= 1
    }

    // 3. 用柯里化实现
    def myWhile3(condition: =>Boolean)(op: =>Unit): Unit = {
      if (condition){
        op
        myWhile3(condition)(op)
      }
    }

    println("=================")
    n = 10
    myWhile3(n >= 1){
      println(n)
      n -= 1
    }
  }
}

5.2.7 惰性加载

1） 说明

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

2） 案例实操

object Test13_Lazy {
  def main(args: Array[String]): Unit = {
    lazy val result: Int = sum(13, 47)

    println("1. 函数调用")
    println("2. result = " + result)
    println("4. result = " + result)
  }

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

// 结果
1. 函数调用
3. sum调用
2. result = 60
4. result = 60