Scala Language Programing Guide（章节五）

作者：jiangzz 电话：15652034180 微信：jiangzz_wx 微信公众账号：jiangzz_wy 百知教育

函数对象

在Java1.8中提出了一个Functional Interface,如果一个接口里面只能有一个抽象方法。这种类型的接口也称为SAM接口，即Single Abstract Method interfaces。将该接口成为函数式接口。

@FunctionalInterface
public interface GreetingService {
    void sayMessage(String message);
}

GreetingService gs=(message) -> System.out.println("hello "+message);
gs.sayMessage("张三");

Java 8为函数式接口引入了一个新注解@FunctionalInterface，主要用于编译级错误检查，加上该注解，当你写的接口不符合函数式接口定义的时候，编译器会报错。更多参考：https://www.cnblogs.com/chenpi/p/5890144.html

部分应用函数

在Scala中同样对所有的函数都可以理解为是一个接口函数。例如在Scala中可以将任意一个函数转变成对象。例如如下定义一个sum函数。

scala> def sum(v1:Int,v2:Int):Int={
     |       v1+v2
     |    }
sum: (v1: Int, v2: Int)Int

在Scala中可以尝试将一个函数转变成一个对象类型，如下：

scala> var sumFuction=sum _
sumFuction: (Int, Int) => Int = <function2>

通常将上述转得到的sumFuction称为sum函数的部分应用函数。例如只修改其中一个参数的值

scala> var sumForOne=sum(_:Int,2)
sumForOne: Int => Int = <function1>

可以看出sumFunction是一个变量，该变量的类型是(Int, Int) => Int其中<function2>是该对象的字面值。在Scala中左右的函数都可以更改成为Function1~22对象的实例。例如

scala> sumFuction.isInstanceOf[Function2[Int,Int,Int]]
res28: Boolean = true

可以看出sumFuction实际上Function2的一个实例而已，因此可以将以上函数定义为一个变量

scala> var sumFunction=new Function2[Int,Int,Int] {
     |     override def apply(v1: Int, v2: Int): Int = v1+v2
     |   }
sumFunction: (Int, Int) => Int = <function2>

scala> sumFunction(1,2)
res31: Int = 3

在Scala中有一种更简洁的方法去描述Function1~22的简便写法,例如改写上诉sum函数

scala> var sumFunction:(Int,Int)=>Int = (x:Int,y:Int)=> x+y
sumFunction: (Int, Int) => Int = <function2>

scala> sumFunction(1,2)
res34: Int = 3

不难看出上诉案例定义了一个变量sumFunction，该变量的类型(Int, Int) => Int该变量的实现是一个匿名函数（前面章节已经涉及，参考匿名函数定义）。因为事实上(Int, Int) => Int就是一种函数类型。

scala> sumFunction.isInstanceOf[ (Int, Int) => Int]
res35: Boolean = true

scala> sumFunction.isInstanceOf[Function2[Int,Int,Int]]
res36: Boolean = true

进一步证实了(Int, Int) => Int就是Function2[Int,Int,Int]一种变体形式。因此可以得到这么个结论

scala> def sum(x:Int,y:Int):Int={
     |     x+y
     |   }

等价

scala> class SumFunction extends  Function2[Int,Int,Int] {
     |   override def apply(v1: Int, v2: Int): Int = {
     |     v1+v2
     |   }
     | }

等价

scala> class SumFunction extends  ((Int,Int)=>Int) {
     |   override def apply(v1: Int, v2: Int): Int = {
     |     v1+v2
     |   }
     | }
defined class SumFunction

scala> var sumFunction=new SumFunction()
sumFunction: SumFunction = <function2>

scala> sumFunction(1,2)
res37: Int = 3

等价

scala> var sumFunction:(Int,Int)=>Int = (x:Int,y:Int)=> x+y
sumFunction: (Int, Int) => Int = <function2>

scala>

PartitalFunction

偏函数主要适用于处理指定类型的参数数据，通常用于集合处理中。定义一个函数，而让它只接受和处理其参数定义域范围内的子集，对于这个参数范围外的参数则抛出异常，这样的函数就是偏函数（顾名思异就是这个函数只处理传入来的部分参数）。偏函数是个特质其的类型为PartialFunction[A,B],其中接收一个类型为A的参数，返回一个类型为B的结果。

def main(args: Array[String]): Unit = {
    Array(1,2,3,"a","b","c").collect(pf1).foreach(println)
}
//自定义偏函数
val pf1 = new PartialFunction[Any, Int] {
  override def isDefinedAt(x: Any): Boolean = {
      if(x.isInstanceOf[Int]) true else false
  }
  override def apply(v1: Any): Int = {
      v1.asInstanceOf[Int]
  }
}
//case 实现偏函数
val pf2 :PartialFunction[Any, Int]={
  case x:Int => x+1
}

更多精彩内容关注