0
点赞
收藏
分享

微信扫一扫

三、Scala学习之函数式编程

驚鴻飛雪 2022-03-15 阅读 66

1.面向对象编程

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

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

2.函数式编程

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

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

2.1基本语法

在这里插入图片描述

2.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 ={

2.3 函数至简原则

函数至简原则:能省则省
1)至简原则细节
(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 + " 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")}))
 }
}

2.4函数的高级用法

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

2.5 匿名函数

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.6 函数柯里化&闭包

闭包:函数式编程的标配
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))
 }
}
举报

相关推荐

0 条评论