第5章 函数式编程**-函数和方法,高阶函数,匿名函数,函数柯里化,闭包,递归,控制抽象(传值参数,传名参数),惰性加载...

这篇具有很好参考价值的文章主要介绍了第5章 函数式编程**-函数和方法,高阶函数,匿名函数,函数柯里化,闭包,递归,控制抽象(传值参数,传名参数),惰性加载...。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

第 5 章 函数式编程-函数和方法,高阶函数,匿名函数,函数柯里化,闭包,递归,控制抽象(传值参数,传名参数),惰性加载


1)面向对象编程

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

对象:用户

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

属性:用户名、密码

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

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

2)函数式编程

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

这些封装好的步骤,解决问题。

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

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

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

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

5.1 函数基础

5.1.1 函数基本语法

1)基本语法

第5章 函数式编程**-函数和方法,高阶函数,匿名函数,函数柯里化,闭包,递归,控制抽象(传值参数,传名参数),惰性加载...

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)核心概念

​ (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 ={
      def test3(name:String):Unit={
 println("函数可以嵌套定义")
 }
 }
 }
}
5.1.3 函数定义

1)函数定义

(1)函数 1:无参,无返回值

(2)函数 2:无参,有返回值

(3)函数 3:有参,无返回值

(4)函数 4:有参,有返回值

(5)函数 5:多参,无返回值

(6)函数 6:多参,有返回值

2)案例实操

package com.atguigu.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)
 }
}
5.1.4 函数参数

1)案例实操

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

函数至简原则:能省则省

1)至简原则细节

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

(2)如果函数体只有一行代码,可以省略花括号

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

(4)如果有 return,则不能省略返回值类型,必须指定

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

(6)Scala 如果期望是无返回值类型,可以省略等号

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

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

(9)如果不关心名称,只关心逻辑处理,那么函数名(def)可以省略

2)案例实操

object TestFunction {
 def main(args: Array[String]): Unit = {
 // (0)函数标准写法
 def f( s : String ): String = {
 return s + " jinlian"
 }
 println(f("Hello"))
 // 至简原则:能省则省
 //(1) return 可以省略,Scala 会使用函数体的最后一行代码作为返回值
 def f1( s : String ): String = {
 s + " jinlian"
 }
 println(f1("Hello"))
 //(2)如果函数体只有一行代码,可以省略花括号
 def f2(s:String):String = s + " jinlian"
 //(3)返回值类型如果能够推断出来,那么可以省略(:和返回值类型一起
省略)
 def f3( s : String ) = s + " jinlian"
 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() {
 "dalang6"
 }
 println(f6())
 //(7)如果函数无参,但是声明了参数列表,那么调用时,小括号,可加可不加
 def f7() = "dalang7"
 println(f7())
     println(f7)
 //(8)如果函数没有参数列表,那么小括号可以省略,调用时小括号必须省
略
 def f8 = "dalang"
 //println(f8())
 println(f8)
 //(9)如果不关心名称,只关心逻辑处理,那么函数名(def)可以省略
 def f9 = (x:String)=>{println("wusong")}
 def f10(f:String=>Unit) = {
 f("")
 }
 f10(f9)
 println(f10((x:String)=>{println("wusong")}))
 }
}

5.2 函数高级

5.2.1 高阶函数

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

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

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

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

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

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

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)如果参数只出现一次,则参数省略且后面参数可以用_代替

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

扩展练习

练习 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 聚合

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

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...")
      10
 }
 foo(f())
 }
 def foo(a: Int):Unit = {
 println(a)
 println(a)
 }
}

2)名调用:把代码传递过去

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)
 }
}
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 类型的变量文章来源地址https://www.toymoban.com/news/detail-409943.html

到了这里,关于第5章 函数式编程**-函数和方法,高阶函数,匿名函数,函数柯里化,闭包,递归,控制抽象(传值参数,传名参数),惰性加载...的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Go中的匿名函数与闭包

    : 函数式编程 闭包 匿名函数 匿名函数特别适合作为函数或方法的回调 在Go中函数是一等公民,和string,int等一样。 而在C、C++ 等不支持匿名函数的语言中,函数不能在运行期创建 go 学习笔记之仅仅需要一个示例就能讲清楚什么闭包 在(普通)函数里面定义一个内部函数

    2024年02月13日
    浏览(50)
  • Go语言入门8(匿名函数 闭包)

    ​顾名思义,就是没有名字的函数。。。 匿名函数的两种执行方法 将匿名函数赋给一个变量 定义后立即执行匿名函数 ​闭包是由函数和与其相关的引用环境组合而成的实体,个人认为就是把一个函数以及函数所用到的参数用另外一个函数包起来,保证函数多次运行的时候,

    2023年04月20日
    浏览(62)
  • Go语言入门9(匿名函数 闭包)

    ​顾名思义,就是没有名字的函数。。。 匿名函数的两种执行方法 将匿名函数赋给一个变量 定义后立即执行匿名函数 ​闭包是由函数和与其相关的引用环境组合而成的实体,个人认为就是把一个函数以及函数所用到的参数用另外一个函数包起来,保证函数多次运行的时候,

    2023年04月24日
    浏览(52)
  • 【PHP】函数-作用域&可变函数&匿名函数&闭包&常用系统函数

    函数:function,是一种语法结构,将实现某一个功能的代码块(多行代码)封装到一个结构中,从而实现代码的重复利用(复用)。 定义函数的目的:是为了实现代码的重复利用,一个功能一个函数(简单明了) 函数的使用:通过 函数名() 的方式进行函数访问 注意: 如果函

    2024年02月11日
    浏览(45)
  • 【Go 基础篇】Go语言匿名函数详解:灵活的函数表达式与闭包

    在Go语言中,函数是一等公民,这意味着函数可以像其他类型的值一样被操作、传递和赋值。匿名函数是一种特殊的函数,它没有固定的函数名,可以在代码中被直接定义和使用。匿名函数在Go语言中具有重要的地位,它们常用于实现闭包、函数式编程和并发编程等领域。 本

    2024年02月11日
    浏览(52)
  • python第6课(函数,内置高阶函数,匿名函数,装饰器)笔记

    变量名的查找规则; 在访问变量时,先查找本地变量,然后是包裹此函数的外部函数的内部变量,之后是全局变量,最后是内置变量 1 在函数内使用全局变量 2使用nonlocal声明的变量不是局部变量,也不是全局变量,而是外部嵌套函数内的变量 函数名是变量,它在创建函数时绑

    2024年02月11日
    浏览(48)
  • 利用闭包与高阶函数实现缓存函数的创建&&缓存函数在项目中的性能优化

    缓存函数是一种用于存储和重复利用计算结果的机制。其基本思想是,当一个函数被调用并计算出结果时,将该结果存储在某种数据结构中 (通常是一个缓存对象)以备将来使用。当相同的输入参数再次传递给函数时,不再执行实际的计算,而是直接返回之前缓存的结果,从而

    2024年02月03日
    浏览(61)
  • Rust编程语言入门之函数式语言特性:-迭代器和闭包

    闭包(closures) 迭代器(iterators) 优化改善 12 章的实例项目 讨论闭包和迭代器的运行时性能 闭包:可以捕获其所在环境的匿名函数。 闭包: 是匿名函数 保存为变量、作为参数 可在一个地方创建闭包,然后在另一个上下文中调用闭包来完成运算 可从其定义的作用域捕获值

    2023年04月08日
    浏览(45)
  • 【跟小嘉学 Rust 编程】十三、函数式语言特性:迭代器和闭包

    【跟小嘉学 Rust 编程】一、Rust 编程基础 【跟小嘉学 Rust 编程】二、Rust 包管理工具使用 【跟小嘉学 Rust 编程】三、Rust 的基本程序概念 【跟小嘉学 Rust 编程】四、理解 Rust 的所有权概念 【跟小嘉学 Rust 编程】五、使用结构体关联结构化数据 【跟小嘉学 Rust 编程】六、枚举

    2024年02月11日
    浏览(59)
  • 【人工智能】LLM 大模型的本质:一个超高阶函数(函数式编程思想,高阶函数),大模型的本质是有巨大数量的函数复合组成的超高阶函数

    LLM 大模型的本质:一个超高阶函数(函数式编程思想,高阶函数),大模型的本质是有巨大数量的函数复合组成的超高阶函数。 —— 禅与计算机程序设计艺术

    2024年02月09日
    浏览(58)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包