Scala常见函数类型，如匿名函数、高阶函数--实例解析

一、匿名函数

在java中我们定义一个函数时是这么写的：

public int funJia(int a,int b){
        int sum = a+b;
        return sum;
    }

funJia 为函数名

在scala中定义一个普通函数的写法：

 def funJia(a:Int,b:Int):Int = {
      var sum = a+b
      return  sum
    }

1.1 定义

两者写法函数名称都为 funJia ，但是在scala中，函数也可以没有名称，即非显式定义一个函数，称为 匿名函数 ，使用匿名函数可以使代码更加简洁、飘逸

1.2 语法

匿名函数语法： (参数名:参数类型) => 函数体
函数体类似于java函数中 {} 的内容
接上例，如：

(a: int,b:int) => a+b

此时可以使用一个变量 result 接收函数返回值，就可以输出打印了

val result = (a: int,b:int) => a+b
println(result(5,3))
//输出结果： 8

定义一个无返回值的匿名函数

val funcSayHello = (name:String) => println("Hello:" +name)
funcSayHello("Kitty")
//输出结果：   Hello:Kitty

二、高阶函数

2.1 定义

java是一种面向对象的语言，而scala既可以面向对象又可以面向函数，是两种方式结合的语言。在scala中，可以把函数当做一个数据类型，像其他数据类型一样被传递和操作。将其他函数作为参数或者使用函数作为输出结果的函数，称为 高阶函数

2.2 示例

2.2.1 定义一个函数：（参数：函数，返回值：String）

定义一个普通函数 funcDemo1 ，传入参数为“函数”和“String”两个类型，返回值类型为 String 类型

//定义加减乘除 四个普通函数
def func1(a:Int,b:Int):Int = a+b  
def func2(a:Int,b:Int):Int = a-b
def func3(a:Int,b:Int):Int = a*b
def func4(a:Int,b:Int):Int = a/b

//再定义一个函数 funcDemo1，传入参数为“函数”和“String”两个类型，返回结果为 String 类型
//此处的函数类型为：(Int,Int)=>Int
def funcDemo1(f:(Int,Int)=>Int,s:String):String={
      var sum:Int = f(200,100)
      return s+sum   //返回值为String类型 s+sum，这里的return关键字可以省略不写
    }
    
//测试：定义str1,2,3,4 四个变量，输出打印
var str1 = funcDemo1(func1,"结果为")
var str2 = funcDemo1(func2,"结果为")
var str3 = funcDemo1(func3,"结果为")
var str4 = funcDemo1(func4,"结果为")
println(str1)
println(str2)
println(str3)
println(str4)

输出结果如下

2.2.2 定义一个函数：（参数：String，返回值：函数）

定义一个普通函数 funcDemo2 ，传入参数类型为 “String”，返回值类型为 “函数”
此处的函数类型为：(String,String) =>String

def funcDemo2(s:String):(String,String) =>String={
    def funcDIY(a:String,b:String):String={   //函数体中内容为自定义一个函数，但是类型与外层返回类型的"函数"一致
     var str:String="输入值："+s+",返回两个值为："+a,b
     return str   //返回一个String类型的结果str，这里的return关键字可以省略不写
    }
    return funcDIY    //返回值为函数类型的值funcDIY，这里的return关键字可以省略不写
  }
//测试：定义一个变量str，输出打印 
//第一个括号("tom")指入参
//第二个括号("eat","drink")指返回值 
var str:String =funcDemo2("tom")("eat","drink")   //此处因为funcDemo2返回类型为"函数"，而此"函数"的返回类型为String，所以使用变量接收funcDemo2的结果，类型也应该为String
println(str)

输入结果如下：

2.2.3 定义一个函数：（参数：函数，返回值：函数）

定义一个普通函数 funcDemo3 ，传入参数类型为 “函数”，返回值类型为 “函数”
此处 入参 的函数类型为：(Int,Int)=>Int
此处 返回 的函数类型为：(String,String) =>String

def funcDemo3(f:(Int,Int)=>Int):(String,String)=>String={
	//函数体中内容如下：
      var sum = f(100,200)   //定义一个变量var，指定入参函数的两Int值为100,200
      def fun1(a:String,b:String):String={   //自定义返回值类型的函数
        a+sum+"，"+b
      }
      fun1   //返回值为函数类型的值 func1
    }
//测试：定义一个变量str，输出打印
//第一个括号((a,b) => {a+b})指入参函数，并且指定函数体为a+b
//第二个括号("你中奖了：","恭喜恭喜")指返回值函数的参数 
var str = funcDemo3((a,b) => {a+b})("你中了","恭喜恭喜")
println(str)    

打印结果如下：

三、递归函数

3.1 定义

递归函数体中，函数本身会自己调用自己的函数

3.2 示例

①：定义一个函数递归相加，实现 "1+2+3+4+5+6…=？"

  def func(num :Int):Int = {
      if (num == 1)
        1
      else
        num + func(num - 1)
    }
    
	//测试
    var result :Int=func(6)  //6+5+4+3+2+1=21
    println(result)
    
	//控制台输出结果：21

②：定义一个函数递归相乘，实现 "123456…=?"

 def func(n: Int): Int = {
      if (n < 1)
        return 0
      else if (n == 1)
        1
      else
        n * func(n - 1)
    }
    
    //测试
    val a = func(5)   //5*4*3*2*1=120
    println(a)
    
    //控制台输出结果：120

四、定义一个函数传递可变长度的参数

在参数类型后面加个 *，可随意传递多个相同类型的参数
例：传递多个String类型的参数

  def funParas(s:String*): Unit={
      for (str <- s){
        println(str)
      }
    }
    
    //测试
    funParas("head","body","foot")
    
    //控制台打印结果：
    //head
    //body
    //foot

五、部分函数

5.1定义

部分函数的逻辑逻辑概念是指调用时缺少部分参数的函数。

5.2示例

//定义一个普通函数，传入三个参数：String,String,Double,打印输出
def showMsg(title:String,content:String,height:Double)={
            println(title+" "+content+":"+height+"m")
          }
//测试 
showMsg("警告","水位超过警戒线",1.0)
//控制台输出结果：警告 水位超过警戒线:1.0m

下面我们来定义一个部分函数：

//首先定义一个常量，标题；“警告”
val title:String="警告"
//定义部分函数showAlert,他的函数体是直接引用直接定义的函数showMsg,将tittle传进来，其余两个参数String、Double使用占位符_ 传入
def showAlert=showMsg(title,_:String,_:Double)

//测试，这时我们在调用showAlert函数时，只需要输入两个参数即可，第一个参数String之前已经传入进来
showAlert("水位超过警戒线",2.0)

//控制台输出结果：警告 水位超过警戒线:2.0m

部分函数的 作用 是： 当在在代码中需要多次调用一个函数函数, 而其中的某个参数又总是相同时, 使用部分函数可以使代码更简洁

六、偏函数

6.1定义

偏函数是指定函数输入输出类型的一种函数 PartialFunction[-T,+V]
有点类似于java中的泛型
偏函数只接受指定类型的参数，并返回指定类型输出

6.2示例

//定义一个函数，判断性别。当输入"male"时返回1，输入"female"时返回0，不能正确识别返回0
def fun:PartialFunction[String,Int] ={
      case "male" => 1
      case "female" => 0
      case _ => -1
    }

//测试： 
println(fun("male"))
println(fun("female"))
println(fun("fasf"))

  //控制台打印结果：
  //1
  //0
  //-1

作用： 如果要筛选信息时，使用偏函数可以起到过滤作用

七、闭包

7.1定义

• 闭包是一个函数，返回值依赖于声明在函数外部的一个或者多个变量。
• 闭包通常来讲可以简单的认为是可以访问一个函数里面局部变量的另一个函数
• 可以访问不在当前作用与范围内的一个函数
• 闭包是一个对于函数参数使用形式上的一种规范，一种概念；函数的创建可以满足闭包这个概念（只要它的返回值依赖了声明在这个函数外部的一个或者多个变量）

7.2示例

def t1 = (i:Int) => i * 10  //定义一个普通函数
println(t1(4))  //4*10 = 40

//定义变量factor，赋予初始值，值为3
var factor = 3
val t2 = (i:Int) => i * factor   //将factor作为参数传入函数，构成闭包，形成一个封闭的函数
println(t2(4))  //4*3 = 12

闭包是一个对于函数参数使用形式上的一种规范，一种概念；函数的创建可以满足闭包这个概念（只要它的返回值依赖了声明在这个函数外部的一个或者多个变量）