Scala (五) --------- 函数式编程

快来打我* 2024-04-08 13:36 65阅读 0赞

#### 目录 ####

*  前言
 *  一、函数基础
 *   *  1. 函数基本语法
     *  2. 函数和方法的区别
     *  3. 函数定义
     *  4. 函数参数
     *  5. 函数至简原则
 *  二、函数高级
 *   *  1. 高阶函数
     *  3. 匿名函数
     *  3. 高阶函数案例
     *  4. 函数柯里化&闭包
     *  5. 递归
     *  6. 控制抽象
     *  7. 惰性加载

--------------------

## 前言 ##

面向对象编程

> 解决问题，分解对象，行为，属性，然后通过对象的关系以及行为的调用来解决问题。  
> 对象：用户  
> 行为：登录、连接 JDBC、读取数据库  
> 属性：用户名、密码

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

函数式编程

> 解决问题时，将问题分解成一个一个的步骤，将每个步骤进行封装 (函数)，通过调用这些封装好的步骤，解决问题。  
> 例如：请求->用户名、密码->连接 JDBC->读取数据库

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

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

## 一、函数基础 ##

### 1. 函数基本语法 ###

**基本语法**

![在这里插入图片描述][3e51dfec906d46dea235a89f7a45937a.png]  
**案例实操**

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

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

### 2. 函数和方法的区别 ###

**核心概念**

*  为完成某一功能的程序语句的集合，称为函数。
 *  类中的函数称之方法。

**案例实操**

*  Scala 语言可以在任何的语法结构中声明任何的语法
 *  函数没有重载和重写的概念；方法可以进行重载和重写
 *  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 ={
        
    	 	def test3(name:String):Unit={
        
     			println("函数可以嵌套定义")
    	 	}
     	}
     }
    }

### 3. 函数定义 ###

**函数定义**

（1）函数 1：无参，无返回值  
（2）函数 2：无参，有返回值  
（3）函数 3：有参，无返回值  
（4）函数 4：有参，有返回值  
（5）函数 5：多参，无返回值  
（6）函数 6：多参，有返回值

**案例实操**

package com.fancy.chapter05
    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)
     }
    }

### 4. 函数参数 ###

**案例实操**

（1）可变参数  
（2）如果参数列表中存在多个参数，那么可变参数一般放置在最后  
（3）参数默认值，一般将有默认值的参数放置在参数列表的后面  
（4）带名参数

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("hehe", "hhh")
    	 // (3) 参数默认值
    	 def test3( name : String, age : Int = 30 ): Unit = {
        
    	 	println(s"$name, $age")
    	 }
    	 // 如果参数传递了值，那么会覆盖默认值
    	 test3("", 20)
    	 // 如果参数有默认值，在调用的时候，可以省略这个参数
    	 test3("hhh")
    	 // 一般情况下，将有默认值的参数放置在参数列表的后面
    	 def test4( sex : String = "男", name : String ): Unit = {
        
    		 println(s"$name, $sex")
    	 }
    	// Scala 函数中参数传递是，从左到右
    	 //test4("hh")
    	 //（4）带名参数
    	 test4(name="heihei")
     }
    }

### 5. 函数至简原则 ###

函数至简原则：能省则省

**至简原则细节**

（1）return 可以省略，Scala 会使用函数体的最后一行代码作为返回值  
（2）如果函数体只有一行代码，可以省略花括号  
（3）返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）  
（4）如果有 return，则不能省略返回值类型，必须指定  
（5）如果函数明确声明 unit，那么即使函数体中使用 return 关键字也不起作用  
（6）Scala 如果期望是无返回值类型，可以省略等号  
（7）如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加  
（8）如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略  
（9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略

**案例实操**

object TestFunction {
        
     def main(args: Array[String]): Unit = {
        
    	 // （0）函数标准写法
    	 def f( s : String ): String = {
        
    	 	return s + "hehe"
    	 }
    	 println(f("Hello"))
    	 // 至简原则:能省则省
    	 //（1） return 可以省略,Scala 会使用函数体的最后一行代码作为返回值
    	 def f1( s : String ): String = {
        
    		 s + " jinlian"
    	 }
    	 println(f1("Hello"))
    	 //（2）如果函数体只有一行代码，可以省略花括号
    	 def f2(s:String):String = s + " hehe"
    	 //（3）返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）
    	 def f3( s : String ) = s + " hehe"
    	 println(f3("Hello3"))
    	 //（4）如果有 return，则不能省略返回值类型，必须指定。
    	 def f4() :String = {
        
    		 return "ximenqing4"
    	 }
    	 println(f4())
    	 //（5）如果函数明确声明 unit，那么即使函数体中使用 return 关键字也不起作用
    	 def f5(): Unit = {
        
    	 	return "dalang5"
    	 }
    	 println(f5())
    	 //（6）Scala 如果期望是无返回值类型,可以省略等号
    	 // 将无返回值的函数称之为过程
    	 def f6() {
        
    	 	"hhh6"
    	 }
    	 println(f6())
    	 //（7）如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可
    	不加
    	 def f7() = "hhh7"
    	 println(f7())
    	 println(f7)
    	 //（8）如果函数没有参数列表，那么小括号可以省略,调用时小括号必须省略
    	 def f8 = "hehe"
    	 //println(f8())
    	 println(f8)
    	 //（9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略
    	 def f9 = ( x:String)=>{
         println("heihei") }
    	 def f10(f:String=>Unit) = {
        
    	 	f("")
    	 }
    	 f10(f9)
    	 println(f10((x:String)=>{
        println("wusong")}))
     }
    }

## 二、函数高级 ##

### 1. 高阶函数 ###

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

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

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

**A、函数可以作为值进行传递**

object TestFunction {
        
      def main(args: Array[String]): Unit = {
        
    	 //（1）调用 foo 函数，把返回值给变量 f
    	 //val f = foo()
    	 val f = foo
    	 println(f)
    	 //（2）在被调用函数 foo 后面加上 _，相当于把函数 foo 当成一个整体，传递给变量 f1
    	 val f1 = foo _
    	 foo()
    	 f1()
    	 //（3）如果明确变量类型，那么不使用下划线也可以将函数作为整体传递给变量
    	 var f2:()=>Int = foo
      }
      def foo():Int = {
        
    	 println("foo...")
    	 1
      }
    }

**B、函数可以作为参数进行传递**

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 _))
     //可以传递匿名函数
    }

**C、函数可以作为函数返回值返回**

def main(args: Array[String]): Unit = {
        
     def f1() = {
        
    	 def f2() = {
        
    	 }
    	 f2 _
     }
     val f = f1()
    // 因为 f1 函数的返回值依然为函数，所以可以变量 f 可以作为函数继续调用
     f()
    // 上面的代码可以简化为
     f1()()
    }

### 3. 匿名函数 ###

**说明**

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

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

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

**案例实操**

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

传递匿名函数至简原则：

（1）参数的类型可以省略，会根据形参进行自动的推导  
（2）类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过 1 的永远不能省略圆括号。  
（3）匿名函数如果只有一行，则大括号也可以省略  
（4）如果参数只出现一次，则参数省略且后面参数可以用\_代替

def main(args: Array[String]): Unit = {
        
    	 // （1）定义一个函数：参数包含数据和逻辑函数
    	 def operation(arr: Array[Int], op: Int => Int) = {
        
    	 	for (elem <- arr) yield op(elem)
     	 }
    	 // （2）定义逻辑函数
    	 def op(ele: Int): Int = {
        
    	 	ele + 1
    	 }
    	 // （3）标准函数调用
    	 val arr = operation(Array(1, 2, 3, 4), op)
    	 println(arr.mkString(","))
    	 // （4）采用匿名函数
    	 val arr1 = operation(Array(1, 2, 3, 4), (ele: Int) => {
        
    	 	ele + 1
    	 })
    	 println(arr1.mkString(","))
    	 // （4.1）参数的类型可以省略，会根据形参进行自动的推导;
    	 val arr2 = operation(Array(1, 2, 3, 4), (ele) => {
        
    		 ele + 1
    	 })
    	 println(arr2.mkString(","))
    	 // （4.2）类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过 1 的永远不能省略圆括号。
    	 val arr3 = operation(Array(1, 2, 3, 4), ele => {
        
    		 ele + 1
    	 })
    	 println(arr3.mkString(","))
    	 // (4.3) 匿名函数如果只有一行，则大括号也可以省略
    	 val arr4 = operation(Array(1, 2, 3, 4), ele => ele + 1)
    	 println(arr4.mkString(","))
    	 //（4.4）如果参数只出现一次，则参数省略且后面参数可以用_代替
    	 val arr5 = operation(Array(1, 2, 3, 4), _ + 1)
    	 println(arr5.mkString(","))
    }

需求 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, _ + _))
     }
    }

### 3. 高阶函数案例 ###

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

object TestFunction {
        
     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)
     }
    }

### 4. 函数柯里化&闭包 ###

闭包：函数式编程的标配

**说明**

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

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

**案例实操**

A、闭包

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. 递归 ###

**说明**

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

**案例实操**

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)
    	 }
      }
    }

### 6. 控制抽象 ###

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

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

**名调用：把代码传递过去**

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 既有值调用，又有名调用。

**案例实操**

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 = 1
    	 myWhile(i <= 10){
        
    		 println(i)
    		 i +=1
    	 }
     }
     def myWhile(condition: =>Boolean)(op: =>Unit):Unit={
        
    	 if (condition){
        
    		 op
    		 myWhile(condition)(op)
    	 }
     }
    }

### 7. 惰性加载 ###

**说明**

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

**案例实操**

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

[3e51dfec906d46dea235a89f7a45937a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/ba3ab415acd346faab0b63b12bfe901f.png