【Scala---04】函数式编程『函数 vs 方法 | 函数至简原则

文章目录

1. 函数 vs 方法
- 1.1 方法
- - (1) 定义方法
  - (2) 运算符即方法
- 1.2 函数
- - (1) 定义函数
  - (2) 匿名函数
- 1.3 方法转为函数
- 1.4 可变参数&默认参数
2. 函数至简原则
3. 函数式编程
- 3.1 函数式编程思想
- 3.3 函数柯里化&闭包
- 3.5 递归 & 尾递归
4. 补充
- 4.1 访问元祖元素
- 4.2 =>的含义
- 4.3 下划线的使用总结

1. 函数 vs 方法

在Java中方法与函数没区别，但是在Scala中方法和函数是不一样的。Java是面向对象的，Scala是面向函数式编程的，主要体现在如下4点：

Java	对象可以作为一个值传递	对象可以作为参数传递	对象可以作为返回值传递	可以调用对象
Scala	函数可以作为一个值传递	函数可以作为参数传递	函数可以作为返回值传递	可以调用函数
Scala	方法不可以作为一个值传递	方法不可以作为参数传递	方法不可以作为返回值传递	可以调用函数

可以看出Scala中函数比方法更加强大，而函数相比于方法最重要的功能就是函数能作为参数传递，也就是说a和b进行的操作不是写死的，而是可变的。

从位置上理解：方法只能在类中定义，做为类的属性；函数可以在任何地方定义。
从是否可以重载的角度：方法定义在类中可以实现重载；函数不可以重载。
从运行位置角度：方法是保存在方法区；函数是保存在堆中。

1.1 方法

(1) 定义方法

定义方法语法如下：

object 类名 {def 方法名([变量：变量类型，变量：变量类型]):返回值类型 = {方法体}
}

比如：
在这里插入图片描述

方法不能作为值传递

object Main {def main(args: Array[String]): Unit = {def add(x:Int, y:Int):Int = {x + y}val result = add   // 会报错println(result)}
}

方法不能作为参数传递

object Main {def main(args: Array[String]): Unit = {// 1. 定义calculate方法def calculate(x: Int, y: Int, func: (Int, Int) => Int): Int = { // x与y进行func操作，这个func函数需要指名 形参类型和返回值func(x, y)}// 2. 定义add方法def add(x:Int, y:Int):Int = {x + y}// 3. 函数作为参数传递val result = calculate(2, 3, add) // 不会报错，自动转为函数传递println(result)}
}

方法不能作为返回值传递

object Main {def main(args: Array[String]): Unit = {// 1. 定义getFunc方法def getFunc() = { // x与y进行func操作，这个func函数需要指名 形参类型和返回值def func(x: Int, y: Int) = {x + y} func  // 会报错}// 2. 得到函数println(getFunc())}
}

方法可以直接调用

object Main {def main(args: Array[String]): Unit = {def add(x: Int, y: Int) = x + yprintln(add(2, 3)) // 输出：5}
}

(2) 运算符即方法

所有的运算符本质上是方法。比如查看Int类

可以看到类中定义了很多以运算符命名的方法

因此，以下两种方法是等价的
```
 val a = 1 + 2val a = 1.+(2)
```

反过来，可以定义这样的方法，并调用

例子1

object Cal {def say(x:Int):Int = x
}object Main {def main(args: Array[String]): Unit = {// 1. 用 类.方法名(参数列表) 形式调用方法var result1 = Cal.say(3)// 2. 用 类 方法 参数列表 形式调用方法var result2 = Cal say (3)  var result3 = Cal say 3    // 如果参数列表只有一个值，括号是可以省略的}
}

例子2

object Main {def say(x:Int):Int = xdef main(args: Array[String]): Unit = {// 1. 用 类.方法名(参数列表) 形式调用方法var result1 = this.say(3)// 2. 用 类 方法 参数列表 形式调用方法var result2 = this say (3)  // 如果参数列表只有一个值，括号是可以省略的var result3 = this say 3}
}

1.2 函数

(1) 定义函数

Scala中有23个函数接口类，函数的本质就是实现这些接口类来实现强大的功能：
在这里插入图片描述

Function0：无参数，无返回值
Function1：…

定义函数语法如下：

object 类名 {def 函数名:([变量类型，变量类型])=>返回值类型 = ([变量：变量类型，变量：变量类型]) => {方法体}
}

比如：
在这里插入图片描述

函数可以作为一个值传递

object Main {def main(args: Array[String]): Unit = {val add = (x:Int, y:Int) => x + yval result = add   // 不会报错println(result) }
}

函数可以作为参数传递，此时需要指名函数的类型。格式为：(参数类型)=>返回值类型

object Main {def main(args: Array[String]): Unit = {// 1. 定义calculate方法def calculate(x:Int, y:Int, func:(Int, Int)=>Int): Int = { // x与y进行func操作，这个func函数需要指名 形参类型和返回值func(x, y)}// 2. 定义add函数def add = (x:Int, y:Int) => x + y// 3. 函数作为参数传递val result = calculate(2, 3, add)// 4. 输出println(result)  // 输出5}
}

函数可以作为返回值传递

object Main {def main(args: Array[String]): Unit = {// 1. 定义getFunc方法def getFunc() = { // x与y进行func操作，这个func函数需要指名 形参类型和返回值val func = (x:Int, y:Int) => x + yfunc}// 2. 得到函数println(getFunc())// 3. 得到函数并执行函数println(getFunc()(2, 3))  // 输出5}
}

函数可以执行

object Main {def main(args: Array[String]): Unit = {val add = (x:Int, y:Int) => x + yprintln(add(2, 3))}
}

(2) 匿名函数

匿名函数与函数的语法区别就在于前者是val关键字，后者是def关键字。比如：
在这里插入图片描述
匿名函数简化了函数值传递：

注意：这只会定义一个函数，也不会执行函数。这点和Java不一样，java的lambda表达式是会创建对象，并执行构造方法。

1.3 方法转为函数

通用转换方式，在方法名后面 + 空格 + _ 即可，语法为：方法名 _

object Main {def main(args: Array[String]): Unit = {def add(x:Int, y:Int):Int = {x + y}val result = add _     // 将方法转为函数println(result(2, 3))  // 输出：5}
}

在参数处将方法转为函数时，可以简化，去掉 _，直接方法名

object Main {def main(args: Array[String]): Unit = {// 1. 定义calculate方法def calculate(x: Int, y: Int, func: (Int, Int) => Int): Int = { // x与y进行func操作，这个func函数需要指名 形参类型和返回值func(x, y)}// 2. 定义add函数def add(x:Int, y:Int):Int = {x + y}// 3. 函数作为参数传递val result1 = calculate(2, 3, add _)      // 此时可优化，去掉 空格_val result2 = calculate(2, 3, add)  // 优化后的代码}
}

1.4 可变参数&默认参数

object Test03_FunArgs {def main(args: Array[String]): Unit = {// (1)可变参数：在类型后面加*号def sayHi(names:String*):Unit = {println(s"hi $names")}sayHi()sayHi("linhai")sayHi("linhai","jinlian")// (2)可变参数必须在参数列表的最后def sayHi1(sex: String,names:String*):Unit = {println(s"hi $names")}// (3)参数默认值def sayHi2(name:String = "linhai"):Unit = {println(s"hi ${name}")}sayHi2("linhai")sayHi2()// (4)默认值参数在使用的时候 可以不在最后def sayHi3( name:String = "linhai" , age:Int):Unit = {println(s"hi ${name}")}// (5)带名参数：指调用方法时，指定传参顺序sayHi3(age = 10, name = "niu")}
}

2. 函数至简原则

在这里插入图片描述

注意：方法最后一行的return可以省略，但是除此之外都不能省略。比如

object Test04_FuncSimply {def main(args: Array[String]): Unit = {//（1）return可以省略，Scala会使用方法体的最后一行代码作为返回值def func1(x: Int, y: Int): Int = {x + y}// （2）如果方法体只有一行代码，可以省略花括号def func2(x: Int, y: Int): Int = x + y//（3）返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）//     此时，函数就变为了数学表达式的形式：f(x, y) = x + ydef func3(x: Int, y: Int) = x + y//（4）如果有return，则不能省略返回值类型，必须指定def func4(x: Int, y: Int): Int = {if (x < 20) {return x + y}2 * x + 3 * y}//（5）如果方法明确声明unit，那么即使函数体中使用return关键字也不起作用def func5(x: Int, y: Int): Unit = return x + y//（6）Scala如果期望是无返回值类型，可以省略等号def func6(x: Int, y: Int) {println(x + y)}// （7）如果方法无参，但是声明了参数列表，那么调用时，小括号，可加可不加def func7(): Unit = {println("hello")}// （8）如果方法没有参数列表，那么小括号可以省略，调用时小括号必须省略def func8 {println("hello")}// （9）如果不关心函数名，只关心映射逻辑，就会变为lambda表达式(x:Int, y:Int) => {println(x + y)}val func = (x:Int, y:Int) => {println(x + y)}  // 如果要设置函数名可以这样。此时，func就是函数名}
}

3. 函数式编程

3.1 函数式编程思想

函数式编程思想：① 当做数学题，y = f(x)，重要的是映射关系。② 使用val，在分布式上计算后不会产生歧义
通过前面可以知道，定义函数有3种形式：
1. 方法转函数。先定义方法，再方法名＿
2. 直接定义函数def
3. 匿名函数

一看到 => 或一看到 _，就要想到这是表示函数。

3.3 函数柯里化&闭包

闭包：内层函数用到了外层函数变量，如果直接调用内层函数会取不到外层函数的这个变量值。此时，内层函数(万物皆对象，函数也是对象)的堆中的对象会保留一份引用到外层函数的值。
闭包参考链接

函数柯里化：将一个接收多个参数的函数转化成一个一个接受参数的函数过程，可以简单的理解为一种特殊的参数列表声明方式。函数柯里化

object TestFunction {val sum = (x: Int, y: Int, z: Int) => x + y + z// 函数柯里化的底层逻辑：本质是将函数作为返回值val sum1 = (x: Int) => {y: Int => {  // 匿名函数z: Int => { // 匿名函数x + y + z}}}// 函数柯里化的另一种简单表达val sum2 = (x: Int) => (y: Int) => (z: Int) => x + y + z// 方法也有函数柯里化def sum3(x: Int)(y: Int)(z: Int) = x + y + zdef main(args: Array[String]): Unit = {sum(1, 2, 3)sum1(1)(2)(3) // sum1(1)调用完后，返回一个函数; sum1(1)(2)是调用返回的函数; .......sum2(1)(2)(3)sum3(1)(2)(3)}
}

3.5 递归 & 尾递归

递归与Java中的递归一样：前面知道scala的方法返回值是可以省略的，默认分配返回值类型，但是如果方法是递归方法，则必须指定方法的返回值类型，否则会报错。

object Test{def main(args: Array[String]): Unit = {// 实现阶乘def fact(n : Int) : Int = {  // 必须指名方法的返回值类型// 跳出递归if(n == 1) return 1// 递归逻辑n * fact(n - 1)}// 调用阶乘方法println(fact(5))}
}

尾递归：递归是将每次调用函数/方法会压入到栈中，是累计使用资源，容易造成栈溢出；而尾递归是覆盖使用资源，不会造成栈溢出。所以，尾递归资源利用率更加高。尾递归参考链接

一般支持函数式编程语言都支持尾递归；但是Java不支持尾递归。

4. 补充

4.1 访问元祖元素

变量名._数字    
比如：x._1 表示访问x的第一个元素

4.2 =>的含义

https://blog.csdn.net/qq_43546676/article/details/130992479

4.3 下划线的使用总结

https://blog.csdn.net/qq_43546676/article/details/130874779