scala支持两种编程范例：面向对象编程（ OOP ）和函数编程（ FP ）。
函数式编程在解决问题时，将问题分解成一个一个的步骤，将每个步骤进行封装(函数)，通过调用这些封装好的步骤，解决问题。
在 Scala 当中，函数既可以作为函数的参数使用，也可以将函数赋值给一个变量. ，函数的创建不用依赖于类或者对象。
函数基础
如果不写等于号和方法主体，那么方法会被隐式声明为抽象(abstract)，包含它的类型于是也是一个抽象类型。
函数和方法的区别
- 函数在scala语言中，是函数编程的 “头等公民”
- 方法是 scala 面向对象中的概念，主要定义在类，特质，抽象类中
- 函数是一个对象，方法本质就是类中的一个普通的方法
- 函数可以作为参数进行传递,可以作为返回值返回,但是方法不行
- 方法可以通过一定的语法转成函数
参考博文：https://blog.csdn.net/mswuxianshen/article/details/84
def main(args: Array[String]): Unit = {
//定义函数
def sayHi(name:String):Unit = {
println("hi,"+name)
}
//调用函数
sayHi(name ="alice")
//调用对象方法
this.sayHi(NAME="Bob")
}
//定义对象的方法
def sayHi(name:String):Unit = {
println("Hi,"+name)
}
返回值
(1)函数1:无参，无返回值
def f1():Unit ={
println("1.无参，无返回值")
}
//调用
f1()
(2)函数2:无参，有返回值
def f2():Int ={
println("1.无参，有返回值")
return 12
}
//调用
println(f2())//12
(3)函数3:有参，无返回值
def f3(name:String):Unit ={
println("3.有参，无返回值"+name)//输出：有参，无返回值alice
}
println(f3(name="alice" ))//输出：()
(4)函数4:有参，有返回值
def f3(name:String):String ={
println("3.有参，无返回值"+name)//输出：有参，无返回值alice
return "hi,"+name
}
println(f3(name="alice" ))//输出：hi,alice
可变参数
Scala 允许指明函数的最后一个参数可以重复，即我们不需要指定函数参数的个数，可以向函数传入可变长度参数列表。
Scala 通过在参数的类型之后放一个星号来设置可变参数(可重复的参数)。
def f1(str:String*):Unit ={
println(str)
}
f1(str="alice")//WrappedArray(alice)
f1("aaa","bbb","ccc")//WrappedArray(aaa, bbb, ccc)
如果参数列表中存在多个参数,那么可变参数一般放置在最后
def f1(str1:String,str2:String*):Unit ={
println("str1 "+str1+"str2 "+str2)
}
f1(str1="alice")//str1 alicestr2 WrappedArray()
f1("aaa","bbb","ccc")//str1 aaastr2 WrappedArray(bbb, ccc)
参数默认值，一般将有默认值的参数放置在参数列表的后面
def f1(str:String="Heria"):Unit ={
println("My name is "+str)
}
f1("Java")//My name is Java
f1()//My name is Heria
函数至简原则：能省则省
现有原始长度函数
def f0(name:String):String ={
return name
}
println(f0("Heria"))
一、return可以省略，Scala 会使用函数体的最后一行代码作为返回值
def f1(name:String):String ={name}
println(f1("Heria"))
二、如果函数体只有一行代码，可以省略花括号
def f2(name:String):String =name
println(f2("Heria"))
三、返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略)
def f3(name:String) =name
println(f3("Heria"))
四、如果有return，则不能省略返回值类型，必须指定
五、如果函数明确声明unit，那么即使函数体中使用return关键字也不起作用
六、Scala如果期望是无返回值类型，可以省略等号
def f6(name:String){
println("Heria")
}
七、如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加
def f7():Unit={
println("Heria")
}
f7
八、如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略
def f8:Unit={
println("Heria")
}
f8
九、如果不关心名称，只关心逻辑处理，那么西数名(def)可以省略
//匿名函数，lambda表达式
(name:String)=>{println(name)}
匿名函数
Scala支持一级函数，函数可以用函数文字语法表达
//匿名函数，lambda表达式
val fun = (name:String)=>{println(name)}
//val stringToUnit: String => Unit = (name:String) => {println(name)}
//以String作为参数，Unit作为返回值的函数
fun("Heria")
匿名函数的主要作用是作为参数参与函数的运行
val fun = (name:String)=>{println(name)}
def f(func:String=>Unit):Unit={
func("Heria")
}
f(fun)
为什么这个函数可以直接打印？因为f函数调用了func这个作为参数的函数，而我们在调用f函数时，是将fun函数作为参数传入的。fun函数需要传入String类型的参数，func("Heria")将Heria作为参数传入。
f()这种类型的函数的目的是为了针对固定的数据，传入不同的函数对数据进行操作
匿名函数的简化原则
f((name:String)=>{println(name)})
一、参数的类型可以省略,会根据形参进行自动的推导
f((name)=>{
println(name)
})
二、类型省略之后，发现只有一个参数，则圆括号可以省略;没有参数和参数超过一的永远不能省略括号。
f(name=>{
println(name)
})
三、匿名函数如果只有一行,则大括号也可以省略
f(name=>
println(name))
四、如果参数只出现一次,则参数省略且后面参数可以用_代替
f(println(_))
五、如果可以推断出，当前传入的println是一个函数体，而不是调用语句，可以直接省略下划线
f(println)
案例实操1
定义一个”二元运算函数，只操作1和2两个数，但是具体运算通过参数传入
def dualFunctionOneAndTwo(fun:(Int,Int)=>Int):Int={
fun(1,2)
}
//1
val add =(a:Int,b:Int)=>a+b
println(dualFunctionOneAndTwo(add)
//2
println(dualFunctionOneAndTwo((a:Int,b:Int)=>a+b))
//3
println(dualFunctionOneAndTwo((a,b)=>a+b))
//4
println(dualFunctionOneAndTwo(_+_))
案例实操2
定义一个函数func，它接收一个Int类型的参数，返回一个函数(记作fl1)。
它返回的函数f1，接收一个string类型的参数，同样返回一个函数（记作2)。函数f2接
收一个Char类型的参数，返回一个Boolean的值。
要求调用函数func(0)(“”)(0)得到返回值为false，其它情况均返回true。
简化前
def func(i: Int): String=>(Char=>Boolean) = {
def f1(s: String): Char=>Boolean = {
def f2(c: Char): Boolean = {
if (i == 0 && s == "" && c == '0')
false else true}
f2
}
f1
}
println(func(0)("")('0'))//false
简化后
def func(i: Int): String=>(Char=>Boolean) = {
s=>c=>if (i == 0 && s == "" && c == '0') false else true
}
println(func(0)("")('0'))//false
柯里化
def func(i:Int)(s:String)(c:Char):Boolean={
if(i==0 && s=="" && c=="0") false else true
}
高阶函数
高阶函数将其他函数作为参数或其结果是函数的函数。
一、函数作为值进行传递
def f(n:Int):Int={
println("f调用")
n+1
}
//val f1:Int=>Int=f
val f2 =f _
二、函数作为参数进行传递
def dualEval(op:(Int,Int)=>Int,a:Int,b:Int):Int={
op(a,b)
}
def add(a:Int,b:Int):Int={
a+b
}
println(dualEval(add,1,2))
println(dualEval((a,b)=>a+b,1,2))
println(dualEval(_+_,1,2))
三、函数作为返回值返回
def f5(): Int=>Unit = {
def f6(a: Int): Unit = {
println("f6调用" +a)}
f6 //将函数直接返回
}
//println(f5())//返回引用
val f6 =f5()
println(f6)//输出：<function1>
println(f6(25))
//输出：f6调用25
// ()
println(f5()(25))
//输出：f6调用25
// ()
案例实操
对数组进行处理，将操作抽象出来，处理完毕之后的结果返回一个新的数组
val arr: Array [Int] = Array(12,45,75,98)
def array0peration(array: Array[Int],op: Int=>Int): Array[Int] = {
for (elem <- array) yield op(elem)
}
//定义一个加一操作
def add0ne(elem: Int): Int = {
elem + 1
}
//调用函数
val newArray: Array[Int] =array0peration(arr,add0ne)
println(newArray.mkString(" , "))//13 , 46 , 76 , 99
柯里化函数
以匿名函数案例实操2为例，原代码为
def func(i: Int): String=>(Char=>Boolean) = {
def f1(s: String): Char=>Boolean = {
def f2(c: Char): Boolean = {
if (i == 0 && s == "" && c == '0')
false else true}
f2
}
f1
}
该代码实现了函数的嵌套，func的返回值是f1，f1返回值是f2，f2返回的是基于条件判断的布尔类型的值。输出时以println(func(0)("")('0'))为例，调用func函数，传入参数0，得到(Char=>Boolean)函数返回值，相当于得到了f1的调用，此时，func的调用已经结束。i作为具备变量已经释放掉，最终在f2中，在语言理解层面是没办法取到i去做条件判断。
**闭包：**能够读取其他函数内部变量的函数。在本质上，闭包是将函数内部和函数外部连接起来的桥梁。
scala在调用函数时，创建一个对象实例，放到堆内存中。这个对象实例中打包了相关环境和局部变量。
案例实操
期望进行两树相加的操作，其中一个数我们希望固定好，但是熬以参数形式传入
变更前
def addBy4():Int=>Int={
val a = 4
def add(b:Int):Int={
a+b
}
add
}
变更后
def addByA():Int=>Int={
val a = 4
def add(b:Int):Int={
a+b
}
add
}
println(addByA(35)(24))
val addByFour=addByA(4)
printlnaddByFour(12)
lamda表达式简化
def addByA(a:Int):Int=>Int = a + _
柯里化(Currying)函数是一个带有多个参数，并引入到一个函数链中的函数，每个函数都使用一个参数。函数柯里化的过程是把一个参数列表的多个参数，变成多个参数列表。
def addCurrying(a:Int)(b:Int):Int={
a+b
}
println(addCurrying(35)(24))
递归
一个函数/方法体内又调用了自身称为递归调用。
阶乘案例
// 1．循环实现
def circle(n: Int) = {
var result = 1
for (i <- 1 to n) {
result *= i
}
result
}
//2.递归实现
def fact(n: Int):Int ={
return fact(n-1)*n
}
上述递归实现虽然能够极大简化程序员编写代码的量，但是对计算机并不友好。return()会先拿到fact(n-1)的值，再将n与之相乘。当调用下一层函数时，内存仍保存有上一层的数据，极大增加了内存的消耗。为了解决这个问题，引入尾递归的概念,即指在一个方法内部，递归调用后直接return，没有任何多余的指令了。尾递归将外层方法的结果传递给了内层方法,当编译器检测到一个函数调用是尾递归的时候，它就覆盖当前的活动记录而不是在栈中去创建一个新的。这样在计算fact(4)时，会先将fact(5)弹栈，再将fact(4)压栈，保证同时只有一个栈帧在栈里存活
def tailFact(n: Int):Int ={
@tailrec
def loop(n:Int,currRes:Int):Int={
if(n == 0) return currRes
loop(n-1,currRes*n)
}
loop(n,1)
}
传值参数和传名参数
传值参数
如下案例所示，定义一个Int类型的参数，调用这个参数的时候就把Int类型的值传给它，相当于变量赋值。
scala
def f0(a: Int): Unit = {
println("a: " + a)
println("a: " + a)
}
f0(23)
传名参数
将一部分代码或代码块作为整体传递给参数，这个过程也叫名调用。
def x():Int={
println("x调用")
12
}
def f1(a: =>Int): Unit = {
println("a: " + a)
println("a: " + a)
}
f1(x())
传名参数的这种调用方式是将a全部替换成x()代码块
案例实操：自定义while循环
常规的while循环
var n: Int = 5
while (n >= 1) {
println(n)
n -= 1
}
用闭包实现一个函数，将代码块作为参数传入，递归调用
def mywhile(condition: =>Boolean): (=>Unit)=>Unit = {
//内层函数需要递归调用，参数就是符环体
def doLoop(op: => Unit): Unit = {
if (condition) {
op
mywhile(condition)(op)
}
}
doLoop _
}
n=10
mywhile(n>=1){
println(n)
n-=1
}
}
用匿名函数实现
def mywhile(condition: =>Boolean): (=>Unit)=>Unit = {
//内层函数需要递归调用，参数就是符环体
op=> {
if (condition) {
op
mywhile(condition)(op)
}
}
n=10
mywhile(n>=1){
println(n)
n-=1
}
柯里化实现
def mywhile(condition: =>Boolean)(op: => Unit):Unit = {
if (condition) {
op
mywhile(condition)(op)
}
}
n=10
mywhile(n>=1){
println(n)
n-=1
}
惰性加载
当函数返回值被声明为lazy时，函数的执行将被推迟，直到我们首次对此取值，该函
数才会执行。这种函数我们称之为惰性函数。
案例实操
lazy val result:Int=sum(13,47)
println("1.函数调用")
println("1.result="+result)
}
def sum(a:Int,b:Int):Int={
println("3.sum调用")
a+b
//结果
//1.函数调用
//3.sum调用
//2.result=60
lazy使sum(13,47)的求值过程变成了懒加载的过程，当前的result变量可以认为是传名参数，只有在第一次调用的时候才会执行（只调用一次sum函数）
260
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
