1. 函数式编程
解决问题时，将问题分解成一个一个的步骤，将每个步骤进行封装（函数），通过调用这些封装好的步骤，解决问题。
Scala语言是一个完全函数式编程语言。万物皆函数。
函数的本质：函数可以当做一个值进行传递
2. 函数和方法的区别
核心概念
- 为完成某一功能的程序语句的集合，称为函数。
- 类中的函数称之方法。
- 定义在方法或者函数内部 称为函数
（1）Scala语言可以在任何 的语法结构中声明任何的语法
（2）函数没有重载和重写的概念；方法可以进行重载和重写
（3）Scala中函数可以嵌套定义
object TestFunction {// (2)方法可以进行重载和重写，程序可以执行def main(): Unit = {}def main(args: Array[String]): Unit = {// （1）Scala语言可以在任何的语法结构中声明任何的语法import java.util.Datenew Date()// (2)函数没有重载和重写的概念，程序报错def test(): Unit ={println("无参，无返回值")}test()def test(name:String):Unit={println()}//（3）Scala中函数可以嵌套定义def test2(): Unit ={def test3(name:String):Unit={println("函数可以嵌套定义")}}}}
3. 函数定义
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)}
4. 函数参数
- 可变参数
- 如果参数列表中存在多个参数，那么可变参数一般放置在最后
- 参数默认值，一般将有默认值的参数放置在参数列表的后面
- 带名参数
// （1）可变参数def test( s : String* ): Unit = {println(s)}// 有输入参数：输出 Arraytest("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. 函数至简原则（重点）
函数至简原则：能省则省
- return可以省略，Scala会使用函数体的最后一行代码作为返回值
- 如果函数体只有一行代码，可以省略花括号
- 返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）
- 如果有return，则不能省略返回值类型，必须指定
- 如果函数明确声明unit，那么即使函数体中使用return关键字也不起作用
- Scala如果期望是无返回值类型，可以省略等号
- 如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加
- 如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略
- 如果不关心名称，只关心逻辑处理，那么函数名（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")}))
}
}
6. 函数高阶用法
函数可以作为值进行传递
//（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
}
函数可以作为参数进行传递
// （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()()
}
7. 匿名函数
（1）参数的类型可以省略，会根据形参进行自动的推导
（2）类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过1的永远不能省略圆括号。
（3）匿名函数如果只有一行，则大括号也可以省略
（4）如果参数只出现一次，则参数省略且后面参数可以用_代替
（5）如果可以推断出，println是一个函数体，而不是调用语句，那么(_)可以省略
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(","))
//（5）如果可以推断出，println是一个函数体，而不是调用语句，那么(_)可以省略
}
}
8. 函数柯里化和闭包
闭包：如果一个函数，访问到了它的外部（局部）变量的值，那么这个函数和他所处的环境，称为闭包
函数柯里化：把一个参数列表的多个参数，变成多个参数列表。
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))
}
}
9. 递归
一个函数/方法在函数/方法体内又调用了本身，我们称之为递归调用
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)
}
}
}
10. 控制抽象
值调用：把函数运行后的值传递过去
object TestControl {
def main(args: Array[String]): Unit = {
def f = ()=>{
println("f...")
10
}
foo(f())
}
def foo(a: Int):Unit = {
println(a)
println(a)
}
}
名调用：把代码块传递过去
object TestControl {
def main(args: Array[String]): Unit = {
def f = ()=>{
println("f...")
10
}
foo(f())
}
//def foo(a: Int):Unit = {
//代码块写法为 变量命名 => 返回值类型 a: =>Int
def foo(a: =>Int):Unit = {//注意这里变量a没有小括号了 变成 a: =>Int
println(a)
println(a)
}
}
//输出结果：
//f...
//10
//f...
//10
Java只有值调用；Scala既有值调用，又有名调用
自定义一个while循环
object TestFunction {
def main(args: Array[String]): Unit = {
var i:Int = 1
myWhile(i <= 10){
println(i)
i +=1
}
}
def myWhile(condition: =>Boolean)(op: =>Unit):Unit={
if (condition){
op
myWhile(condition)(op)
}
}
}
11. 惰性函数
当函数返回值被声明为laz时，函数的执行将被推迟，直到我们首次对此取值，该函数才会执行。这种函数我们称之为惰性函数。
def main(args: Array[String]): Unit = {
lazy val res = sum(10, 30) //通过lazy关键字
println("----------------")
println("res=" + res)
}
def sum(n1: Int, n2: Int): Int = {
println("sum被执行。。。")
return n1 + n2
}
输出结果
----------------
sum被执行。。。
res=40
若有收获，就点个赞吧
0 人点赞
