Scala（自学-3）

南城守护

已于 2023-02-15 20:32:50 修改

阅读量375

点赞数 1

文章标签：大数据

于 2022-07-15 21:41:43 首次发布

本文链接：https://blog.youkuaiyun.com/W2484980893/article/details/125812272

版权

本文深入探讨Scala编程，解析函数基础与高级特性。从函数定义、调用、参数处理等方面阐述函数式编程的核心思想，同时讨论Scala中函数与面向对象编程的融合，包括函数作为值传递、作为参数和返回值。通过实例展示了高阶函数的使用，如匿名函数、函数作为整体传递和返回，强调函数至简原则。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

五、函数式编程

a、函数基础

b、函数高级

五、函数式编程

面向对象编程

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

对象：用户

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

属性：用户名、密码

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

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

函数式编程

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

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

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

函数的本质：在 Scala 中函数式编程和面向对象编程完美融合在一起了。函数可以当做一个值进行传递

a、函数基础

函数基本语法

def sum （x：Int , y：Int ) : Int = {
    x + y
}
//def 定义函数的关键字
//sum 函数名
//x （参数名） ： Int （参数类型）： Int （函数返回类型）
//{    x+y  (函数体）

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

；

函数和方法的区别
1. 位完成某一功能的程序语句的集合，称为函数。
2. 类中的函数称之方法
3. 注意：
  1. Scala 语言可以在任何的语法结构中声明任何的语法
  2. 函数没有重载和重写的概念；方法可以进行重载和重写
  3. Scala 中函数可以嵌套定义
函数的定义
1. 函数 1：无参，无返回值
2. 函数 2：无参，有返回值
3. 函数 3：有参，无返回值
4. 函数 4：有参，有返回值
5. 函数 5：多参，无返回值
6. 函数 6：多参，有返回值
函数参数
1. 可变参数
```
// （1）可变参数
 def test( s : String* ): Unit = {
 println(s)
 }
```
2. 如果参数列表中存在多个参数，那么可变参数一般放置在最后
```
// (2)如果参数列表中存在多个参数，那么可变参数一般放置在最后
 def test2( name : String, s: String* ): Unit = {
 println(name + "," + s)
 }
```
3. 参数默认值，一般将有默认值的参数放置在参数列表的后面
```
// (3)参数默认值
 def test3( name : String, age : Int = 30 ): Unit = {
 println(s"$name, $age")
 }
```
  注意：
  1. 如果参数传递了值，那么会覆盖默认值
  2. 如果参数有默认值，在调用的时候，可以省略这个参数
  3. 一般情况下，将有默认值的参数放置在参数列表的后面
  4. Scala 函数中参数传递是，从左到右
4. 带名参数
```
//（4）带名参数
 test4(name="ximenqing")
```

函数至简原则（重点）

函数至简原则：能省则省

至简原则细节

// （0）函数标准写法
 def f( s : String ): String = {
 return s + " jinlian"
 }
 println(f("Hello"))

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

//（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"))

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

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

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

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

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

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

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

//（7）如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可
不加
 def f7() = "dalang7"
 println(f7())
 println(f7)

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

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

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

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

b、函数高级

高阶函数

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

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

函数的高阶用法：

函数可以作为值进行传递

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

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

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

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

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

匿名函数

说明
1. 没有名字的函数就是匿名函数。
2. (x:Int)=>{函数体}
3. (x:Int)=>{函数体}

传递匿名函数至简原则：

参数的类型可以省略，会根据形参进行自动的推导。
```
println(calculator(2, 3, (x , y) => x + y))
```
类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过 1 的永远不能省略圆括号。
匿名函数如果只有一行，则大括号也可以省略。
```
println(calculator(2, 3, (x: Int, y: Int) => x + y))
```

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

println(calculator(2, 3, _ + _))

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