Skip to content

第 5 章 函数式编程

1) 面向对象编程

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

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

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

2) 函数式编程

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

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

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

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

5.1 函数基础

5.1.1 函数基本语法

1) 基本语法

2) 案例实操

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

java
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) 案例实操

scala
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) 带名参数

scala
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) 案例实操

scala
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 中,函数是一等公民。怎么体现的呢? 对于一个函数我们可以:定义函数、调用函数

scala
object TestFunction {

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

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

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

scala
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) 函数可以作为参数进行传递

scala
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) 函数可以作为函数返回值返回

scala
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 聚合

scala
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 类型的变量

Released under the MIT License.