scala底子学习_方法&函数

方法与函数

函数（又称函数值/匿名函数）

• 界说在任何地方：函数可以界说在类的成员中，也可以界说在顶层（即不在任何类或对象中这是scala3特性）。
  
• 不能访问类的私有成员：除非函数界说在类内部，否则它不能访问类的私有成员。
  
• 是一等公民：函数可以作为值转达，可以赋值给变量，可以存储在数据结构中，可以作为其他函数的参数或返回值。
  
• 可以利用函数字面量界说：函数可以利用 => 符号界说匿名函数。
  

=> 符号在 Scala 中用于界说匿名函数，它提供了一种轻便的方式来界说函数，特别是在必要将函数作为参数转达给其他函数时。匿名函数是函数式编程的紧张构成部门，使代码更加机动和可组合。
在 Scala 中，匿名函数（也称为 lambda 表达式）通常与 val 一起利用，而不是 var。这是由于匿名函数本身是一个值，而且你通常不盼望重新赋值给这个函数。‘
界说方法

val 函数名:函数范例=>返回范例 = （现实传入参数）=>表达式
轻便情势：这种情势的匿名函数直接将参数和表达式放在 => 符号的两侧。这种情势的函数没有函数体，因此它的返回值是 => 右侧表达式的结果。

1. // 定义参数类型返回类型，定义参数，表达式
2. val ldsx2: (Int, Int) => Unit = (a, b) => println(a, b)
3. // 定义参数 参数类型，表达式
4. val ldsx2 = (a:Int, b:Int) => println(a, b)

复制代码

带函数体情势：这种情势的匿名函数利用花括号 {} 来界说函数体。函数体中的末了一个表达式是函数的返回值。

1. val ldsx3: (Int, Int) => Unit = (a, b) => {
2.   println(a, b)
3. }

复制代码

界说部门
(Int, Int) => Unit 是 Scala 中的一种函数范例体现法，它体现一个担当两个 Int 范例参数并返回 Unit 范例结果的函数。这种体现法通常用于界说匿名函数（lambda 表达式）或高阶函数。
详细来说：

• (Int, Int): 这部门体现函数担当两个参数，这两个参数的范例都是 Int。
  
• =>: 这个符号体现函数范例。
  
• Unit: 这部门体现函数的返回范例。Unit 是 Scala 中的一个特别范例，体现没有值，雷同于 Java 中的 void。
  

因此，(Int, Int) => Unit 体现一个函数范例，这个函数担当两个 Int 范例的参数，并返回 Unit 范例的结果。这意味着这个函数实行一些操纵，但不返回任何值。
以下是一个利用 (Int, Int) => Unit 函数范例的例子：
表达式部门

• (a, b): 这部门界说了匿名函数的参数列表。这个匿名函数担当两个参数，分别是 a 和 b。
  
• =>: 这个符号体现函数字面量的开始。
  
• { println(a, b) }: 这部门是匿名函数的主体，它是一个代码块。这个代码块包罗一个表达式 println(a, b)，这个表达式打印参数 a 和 b 的值。
  

注意

在 Scala 中，当匿名函数的主体只包罗一个表达式时，花括号 {} 可以省略。同样，当匿名函数只有一个参数时，圆括号 () 也是可选的。这些简化使得代码更轻便，但也保持了代码的可读性。

• 花括号 {}：
  花括号用于界说匿名函数的主体。当匿名函数的主体只包罗一个表达式时，花括号可以省略。比方：
  
  1. // 使用花括号
  2. val result1 = ary.filter( n => { n == 2 })
  4. // 不使用花括号
  5. val result2 = ary.filter(n => n == 2)

  复制代码
  在这两个例子中，n => n == 2 是一个匿名函数，它担当一个参数 n 并返回一个布尔值，体现 n 是否便是 2。当匿名函数的主体只有一个表达式时，花括号是可选的。
  
• 圆括号 ()：
  圆括号用于界说匿名函数的参数列表。当匿名函数只有一个参数时，圆括号也是可选的。比方：
  
  1. // 使用圆括号
  2. val result3 = ary.filter((n) => n == 2)
  4. // 不使用圆括号
  5. val result4 = ary.filter(n => n == 2)

  复制代码
  在这两个例子中，n => n == 2 和 (n) => n == 2 都是有效的匿名函数。当匿名函数只有一个参数时，圆括号是可选的。
  

单参数函数

1. val square: Int => Int = x => x * x
3. // 调用匿名函数
4. println(square(5)) // 输出 25
6. val square = x:Int => x*x

复制代码

在这个例子中，square 是一个匿名函数，它担当一个 Int 范例的参数 x，并返回 x 的平方。
多参数函数

1. val add: (Int, Int) => Int   =     (a, b) => a + b
3. // 调用匿名函数
4. println(add(3, 4)) // 输出 7

复制代码

在这个例子中，add 是一个匿名函数，它担当两个 Int 范例的参数 a 和 b，并返回它们的和。

1. val add: (Int, Int) => Int = (a, b) => a + b

复制代码

这行代码界说了一个名为 add 的值，它现实上是一个匿名函数（也称为函数字面量）。下面是详细的语法表明：

• val add:
  
  
  
  • val 是一个关键字，用于界说一个不可变的值（雷同于常量）。
    
  • add 是这个值的名称。
    
  
  
• : (Int, Int) => Int:
  
  
  
  • 这部门界说了 add 的范例。
    
  • (Int, Int) 体现这个函数担当两个 Int 范例的参数。
    
  • => 符号体现函数的参数和返回值之间的映射。
    
  • Int 体现这个函数返回一个 Int 范例的结果。
    
  • 因此，(Int, Int) => Int 体现这是一个担当两个 Int 参数并返回 Int 结果的函数范例。
    
  
  
• = (a, b) => a + b:
  
  
  
  • = 符号用于将右侧的匿名函数赋值给左侧的 add。
    
  • (a, b) 体现匿名函数的参数列表，此中 a 和 b 是两个 Int 范例的参数。
    
  • => 符号体现参数和函数体之间的映射。
    
  • a + b 是函数体，体现将参数 a 和 b 相加并返回结果。
    
  
  

综上所述，这行代码界说了一个名为 add 的值，它是一个担当两个 Int 参数并返回它们之和的匿名函数。你可以像调用平常函数一样调用 add：

1. println(add(3, 4)) // 输出 7

复制代码

在这个例子中，add(3, 4) 调用了匿名函数 (a, b) => a + b，此中 a 被赋值为 3，b 被赋值为 4，函数体 a + b 盘算结果为 7，并打印出来。
函数作为参数转达

匿名函数通常用作高阶函数的参数。高阶函数是可以担当函数作为参数或返回函数作为结果的函数。

1. object Scalafunc {
2.   def main(args:Array[String]):Unit={
3.     // 匿名函数定义
4.     val fc :(Int,Int)=>Int = (a,b) =>a+b
5.     println(fc(1,2))
7.     greet("ldsx")
9.     lambda_func((a,b)=>a+b,1,"3")
10.   }
12.   def greet(name: String): Unit = {
13.     println(s"Hello, $name!")
14.   }
16.   def lambda_func(func :(Int,String)=>String,a:Int,b:String):Unit={
17.     val data = func(a,b)
18.     println(data)
20.   }
22. }

复制代码

在lambda_func中，参数分为二部门，共三个

• func Int,String)=>String
  
  
  
  • 第一个参数担当匿名函数名称 func
    
  • 这个参数量是设置好匿名函数名称，确认匿名函数func担当的参数 与返回的数据范例
    
  
  
• a:Int,b:String
  
  
  
  • a,b 为 func所需的参数，但是必要通过lambda_func传入函数内部给func调用
    
  
  

方法

• 界说在类或对象中：方法界说在类或对象内部，是类或对象的一部门。
  
• 可以访问类的成员：方法可以访问类的私有成员（如变量和其他方法）。
  
• 不是一等公民：方法不能直接作为值转达，不能赋值给变量，不能存储在数据结构中，也不能作为其他方法的参数或返回值。
  
• 利用 def 关键字界说：方法利用 def 关键字界说。
  

1. object Scalafunc {
2.   val ldsx = "hello"
3.   def main(args:Array[String]):Unit={
4.     // 匿名函数定义
5.     val fc :(Int,Int)=>Int = (a,b) =>a+b
6.     println(fc(1,2))
8.     greet("ldsx")
9.     // 访问成员
10.     println(ldsx)
11.   }
12.   def greet(name: String): Unit = {
13.     println(s"Hello, $name!")
14.   }
16. }

复制代码

将方法转换为函数

固然方法不是一等公民，但你可以通过将方法转换为函数来利用它。这可以通过在方法反面加上一个下划线 _ 来实现。

1. class MyClass {
2.   def greet(name: String): String = {
3.     s"Hello, $name!"
4.   }
5. }
7. val myObject = new MyClass
8. val greetFunction: String => String = myObject.greet _
10. println(greetFunction("Scala")) // 输出 "Hello, Scala!"

复制代码

在这个例子中，myObject.greet _ 将 greet 方法转换为了一个函数。
方法的返回值

在 Scala 中，函数和方法不必要显式地利用 return 关键字来返回值。Scala 的函数和方法会返回其末了一个表达式的结果，

1. def add(a: Int, b: Int): Int = {
2.   a + b // 这个表达式的结果会被返回
3. }
4. val result = add(3, 4)
5. println(result) // 输出 7

复制代码

在 Scala 中，过程方法是一种不返回任何值的方法。过程方法的返回范例是 Unit，你可以省略 Unit，由于编译器可以推断出返回范例。以下是一个过程方法的示例

1. // 定义Unit过程方法不会有返回值
2. def fun3(a:String):Unit={
3.   var info_d = "aaaa"
4.   info_d
5. }
7. // 设置返回值将会返回最后一个表达式 info_d
8. def fun4(a:String):String={
9.   var info_d = "aaaa"
10.   info_d
11. }
13. // 当最后一个表达式是print 则报错，因为print
14. def fun4(a: String): String = {
15.       var info_d = a
16.       info_d
17.       println(info_d)
18.     }
20. // 不定义返回值 自动编译判断，当你返回表达式有结果时为过程函数，当返回值时为返回值函数
21. def fun4(a: String) = {
22.   var info_d = a
23.   println(info_d,111)
24.   a
25. }
27.    

复制代码

总结

• 方法 是类或对象的一部门，可以访问类的私有成员，但不是一等公民。
  
• 函数 可以在任何地方界说，不能直接访问类的私有成员（除非在类内部界说），但它们是一等公民，具有更大的机动性和功能性。