第 5 章 函数式编程

1） 面向对象编程

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

行为：登录、连接 JDBC、读取数据库属性：用户名、密码

Scala 语言是一个完全面向对象编程语言。万物皆对象对象的本质：对数据和行为的一个封装

2） 函数式编程

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

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

Scala 语言是一个完全函数式编程语言。万物皆函数。函数的本质：函数可以当做一个值进行传递

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

5.1 函数基础

5.1.1 函数基本语法

1） 基本语法

2） 案例实操

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

package com.neuedu.scala

object TestFunction {

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

    // （1）函数定义
    def f(arg: String): Unit = {
      println(arg)
    }

    // （2）函数调用
    // 函数名（参数）
    f("hello world")
  }
}

5.1.2 函数和方法的区别

1） 核心概念

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

（2） 类中的函数称之方法。

2） 案例实操

（1） Scala 语言可以在任何的语法结构中声明任何的语法

（2） 函数没有重载和重写的概念；方法可以进行重载和重写

（3） Scala 中函数可以嵌套定义

object TestFunction {

// (2)方法可以进行重载和重写，程序可以执行def main(): Unit = {

}

def main(args: Array[String]): Unit = {
// （1）Scala 语言可以在任何的语法结构中声明任何的语法
import java.util.Date new Date()

// (2)函数没有重载和重写的概念，程序报错def test(): Unit ={
println("无参，无返回值")
}
test()

def test(name:String):Unit={ println()
}

//（3）Scala 中函数可以嵌套定义
def test2(): Unit ={

5.1.3 函数定义

1） 函数定义

（1） 函数 1：无参，无返回值

（2） 函数 2：无参，有返回值

（3） 函数 3：有参，无返回值

（4） 函数 4：有参，有返回值

（5） 函数 5：多参，无返回值

（6） 函数 6：多参，有返回值

2） 案例实操

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

    // 函数 1：无参，无返回值
    def test1(): Unit = {
      println("无参，无返回值")
    }

    test1()

    // 函数 2：无参，有返回值
    def test2(): String = {
      return "无参，有返回值"
    }

    println(test2())

    // 函数 3：有参，无返回值
    def test3(s: String): Unit = {
      println(s)
    }

    test3("jinlian")

    // 函数 4：有参，有返回值
    def test4(s: String): String = {
      return s + "有参，有返回值"
    }

    println(test4("hello "))

    // 函数 5：多参，无返回值
    def test5(name: String, age: Int): Unit = {
      println(s"$name, $age")
    }

    test5("dalang", 40)
  }


}

5.1.4 函数参数

1） 案例实操

（1） 可变参数

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

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

（4） 带名参数

package com.neuedu.scala.chapter05

object TestFunction {

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

    // （1）可变参数
    def test(s: String*): Unit = {
      println(s)
    }

    // 有输入参数：输出 Array test("Hello", "Scala")

    // 无输入参数：输出List() test()

    // (2)如果参数列表中存在多个参数，那么可变参数一般放置在最后
    def test2(name: String, s: String*): Unit = {
      println(name + "," + s)
    }

    test2("太白金星", "悟空")

    // (3)参数默认值
    def test3(name: String, age: Int = 30): Unit = {
      println(s"$name, $age")
    }

    // 如果参数传递了值，那么会覆盖默认值
    test3("太白金星", 20)

    // 如果参数有默认值，在调用的时候，可以省略这个参数
    test3("悟空")

    // 一般情况下，将有默认值的参数放置在参数列表的后面
    def test4(sex: String = "男", name: String): Unit = {
      println(s"$name, $sex")
    }

    // Scala 函数中参数传递是，从左到右
//    test4("孙悟空") error

    //（4）带名参数
     test4(name="杨戬")
  }

}

5.1.5 函数至简原则（重点）

函数至简原则：能省则省

1） 至简原则细节

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

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

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

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

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

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

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

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

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

2） 案例实操

package com.neuedu.scala.chapter05

object TestFunction {

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

    // （0）函数标准写法
    def f(s: String): String = {
      return s + " 孙悟空"
    }

    println(f("Hello"))

    // 至简原则:能省则省
    //（1） return 可以省略,Scala 会使用函数体的最后一行代码作为返回值
    def f1(s: String): String = {
      s + " 孙悟空"
    }

    println(f1("Hello"))

    //（2）如果函数体只有一行代码，可以省略花括号
    def f2(s: String): String = s + " 孙悟空"

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

    println(f3("Hello3"))

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

    println(f4())

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

    println(f5())

    //（6）Scala 如果期望是无返回值类型,可以省略等号
    // 将无返回值的函数称之为过程
    def f6() {
      "太上老君6"
    }

    println(f6())

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

    def f7() = "太上老君7"

    println(f7)

    //（8）如果函数没有参数列表，那么小括号可以省略,调用时小括号必须省 略
    def f8 = "太上老君"
    //println(f8()) println(f8)

    //（9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略
    def f9 = (x: String) => {
      println("太白金星")
    }

    def f10(f: String => Unit) = {
      f("")
    }

    f10(f9)
    println(f10((x: String) => {
      println("太白金星")
    }))
  }
}

5.2 函数高级

5.2.1 高阶函数

在 Scala 中，函数是一等公民。怎么体现的呢？ 对于一个函数我们可以：定义函数、调用函数

object TestFunction {

    def main(args: Array[String]): Unit = {
        // 调用函数
        foo()
    }
    // 定义函数
    def foo():Unit = {
    	println("foo...")
    }
}

但是其实函数还有更高阶的用法

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

package com.neuedu.scala.chapter05

/**
 * @auth 金山老师
 *       creatime: 2022-10-24 13:02
 *       描述 : ${dc}
 */
object TestFunction {
  def main(args: Array[String]): Unit = {

    //（1）调用 foo 函数，把返回值给变量f
    //val f = foo()
    val f = foo
    println(f)
    //    传递给变量 f1
    val f1 = foo _

    foo()
    f1()
    //（3）如果明确变量类型，那么不使用下划线也可以将函数作为整体传递给变量
    var f2: () => Int = foo
  }

  def foo(): Int = {
    println("foo...")
    1
  }

}

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

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

    //（1）定义一个函数，函数参数还是一个函数签名；f 表示函数名称;(Int,Int)表示输入两个 Int 参数；Int 表示函数返回值
    def f1(f: (Int, Int) => Int): Int = { f(2, 4)
    }

    // （2）定义一个函数，参数和返回值类型和f1 的输入参数一致
    def add(a: Int, b: Int): Int = a + b

    // （3）将 add 函数作为参数传递给 f1 函数，如果能够推断出来不是调用，_ 可以省略
    println(f1(add)) println(f1(add _))
    //可以传递匿名函数
}

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

def main(args: Array[String]): Unit = {
    def f1() = {
        def f2() = {

        }
        f2 _
    }

    val f = f1()
    // 因为f1 函数的返回值依然为函数，所以可以变量f 可以作为函数继续调用
    f()
    // 上面的代码可以简化为
    f1()()
    }
 }

5.2.2 匿名函数

1） 说明

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

(x:Int)=>

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

2） 案例实操

需求 1：传递的函数有一个参数传递匿名函数至简原则：

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

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

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

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

需求 2：传递的函数有两个参数

object TestFunction { def main(args: Array[String]): Unit = { def calculator(a: Int, b: Int, op: (Int, Int) => Int): Int= {op(a, b)} // （1）标准版println(calculator(2, 3, (x: Int, y: Int) => {x + y})) // （2）如果只有一行，则大括号也可以省略println(calculator(2, 3, (x: Int, y: Int) => x + y)) // （3）参数的类型可以省略，会根据形参进行自动的推导; println(calculator(2, 3, (x , y) => x + y)) // （4）如果参数只出现一次，则参数省略且后面参数可以用_代替println(calculator(2, 3, _ + _))}}

扩展练习

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

为 Int，String，Char，返回值类型为Boolean。

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

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

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

5.2.3 高阶函数案例

需求：模拟 Map 映射、Filter 过滤、Reduce 聚合

package com.neuedu.scala.chapter05

import scala.collection.mutable.ArrayBuffer

/**
 * @auth 金山老师
 *       creatime: 2022-10-23 18:37
 *       描述 : ${dc}
 */

object Test01_Function {

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

    // （1）map 映射
    def map(arr: Array[Int], op: Int => Int) = {
      for (elem <- arr) yield op(elem)
    }

    val arr = map(Array(1, 2, 3, 4), (x: Int) => {
      x * x
    })
    println(arr.mkString(","))

    // （2）filter 过滤。有参数，且参数再后面只使用一次，则参数省略且后面参数用_表示
    def filter(arr: Array[Int], op: Int => Boolean) = {
      var arr1: ArrayBuffer[Int] = ArrayBuffer[Int]()
      for (elem <- arr if op(elem)) {
        arr1.append(elem)
      }
      arr1.toArray
    }

    var arr1 = filter(Array(1, 2, 3, 4), _ % 2 == 1)
    println(arr1.mkString(","))

    // （3）reduce 聚合。有多个参数，且每个参数再后面只使用一次，则参数省略且后面参数用_表示，第n 个_代表第n 个参数
    def reduce(arr: Array[Int], op: (Int, Int) => Int) = {

      var init: Int = arr(0)

      for (elem <- 1 until arr.length) {
        init = op(init, elem)
      }
      init
    }

    //    val arr2 = reduce(Array(1, 2, 3, 4), (x, y) => x * y)
    val arr2 = reduce(Array(1, 2, 3, 4), _ * _)
    println(arr2)
  }
}

5.2.4 函数柯里化&闭包

闭包：函数式编程的标配

1） 说明

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

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

2） 案例实操

（1）闭包

object TestFunction {

def main(args: Array[String]): Unit = { 
	def f1()={
    	var a:Int = 10 
        def f2(b:Int)={
            a + b
        }
        f2 _
    }

    // 在调用时，f1 函数执行完毕后，局部变量a 应该随着栈空间释放掉
    val f = f1()

    // 但是在此处，变量a 其实并没有释放，而是包含在了 f2 函数的内部，形成了闭合的效果
    println(f(3))

    println(f1()(3))
    // 函数柯里化，其实就是将复杂的参数逻辑变得简单化,函数柯里化一定存在闭包
    def f3()(b:Int)={ 
    		a + b
    	}
    	println(f3()(3))
    }

5.2.5 ttttttttttttttttttScala24073.png)递归

1） 说明

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

2） 案例实操

object TestFunction { def main(args: Array[String]): Unit = { // 阶 乘// 递归算法// 1) 方法调用自身// 2) 方法必须要有跳出的逻辑// 3) 方法调用自身时，传递的参数应该有规律// 4) scala 中的递归必须声明函数返回值类型println(test(5))} def test(i : Int) : Int = { if (i == 1) {1} else {i * test(I - 1)}}}

5.2.6 控制抽象

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

object TestControl {def main(args: Array[String]): Unit = { def f = ()=>{println("f...")

2） ttttttttttttttttttScala24498.png)名调用：把代码传递过去

object TestControl {def main(args: Array[String]): Unit = { def f = ()=>{println("f...")10} foo(f())} //def foo(a: Int):Unit = {def foo(a: =>Int):Unit = {//注意这里变量 a 没有小括号了println(a) println(a)}}输出结果：f... 10 f...10

注意：Java 只有值调用；Scala 既有值调用，又有名调用。

3） 案例实操

object TestFunction { def main(args: Array[String]): Unit = { // （1）传递代码块foo({println("aaa")}) // （2）小括号可以省略foo{println("aaa")}}



 def foo(a: =>Unit):Unit = { println(a)println(a)}}

自定义一个 While 循环

object TestFunction {def main(args: Array[String]): Unit = { var i:Int = 1myWhile(i <= 10){ println(i)i +=1}}def myWhile(condition: =>Boolean)(op: =>Unit):Unit={ if (condition){op myWhile(condition)(op)}}}

5.2.7 惰性加载

1） 说明

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

2） 案例实操

def main(args: Array[String]): Unit = { lazy val res = sum(10, 30) println(" ")println("res=" + res)} def sum(n1: Int, n2: Int): Int = {println("sum 被执行。。。") return n1 + n2}

输出结果：

----------------sum 被执行。。。

res=40

注意：lazy 不能修饰 var 类型的变量