Scala - implicit 我去给你买个橘子

Scala 是一门比较神奇的语言，提供了许多让人措不及防的关键字与语法。虽然开头有点僵硬，但是还是拦不住我说：这里来了解一下 Scala 中 implicit 关键字吧。

implicit 可以翻译成 “隐喻” -- 将两个看似毫无关系的两个东西，用看不见的丝将他们联系起来。比如月亮与思念、太阳与女神、“我去给你买个橘子”与“我是你爸爸”。可以让收到隐喻后恍然大悟的人们瑟瑟发抖或者破口大骂。

以最后的一个隐喻作为例子，我们首先创建两个类。

IBugOrange 代表“我去买个橘子”。该类需要一个 Int,代表希望买到的橘子数。totalMoney() 得到橘子一共需要的花费。

class IBugOrange(val number: Int) {

  val per: Int = 1

  def totalMoney() : Int = per * number

}

IAmFather 代表 “我是你爸爸”，现在有一个 talk() 方法，直接输出 “爸爸” 想要说的话。

class IAmFather(val money: Int) {

  def talk() = println(s"Stand here!($money)!")

}

赋值转换

如果朱自清没有写《背影》，上面两个类不会有什么联系，于是我们无法把 IBugOrange 实例赋值给 IAmFather：

val iAmFather: IAmFather = new IBugOrange(5) // error

为了能够完成上面的赋值操作，我们可以使用 implicit 创建一个隐喻：

implicit def originToFather(iBugOrange: IBugOrange): IAmFather 
    = new IAmFather(iBugOrange.totalMoney)

跟简单，我们得到了一个使用 implicit 修饰的方法，该方法接受一个 IBugOrange, 返回一个 IAmFather,也就是建立了两者的联系。

当我们将该隐喻放在赋值代码的作用域中，就可以发现上面的赋值操作已经可以实现了。

implicit def originToFather(iBugOrange: IBugOrange): IAmFather 
    = new IAmFather(iBugOrange.totalMoney)
    
val iAmFather: IAmFather = new IBugOrange(5)  // pass

隐喻函数也可以放在 IBugOrange 或 IAmFather 的联盟对象中。或者将隐喻函数 import 到作用域中。

而上面的赋值能够成功，得益于编译器的辛劳。当编译器发现正常的类型匹配失败的时候，他会试图在语句对应的作用域中寻找能够完成对应类型转换的隐喻函数，这里就是函数 originToFather，将IBugOrange转成IAmFather。

可以想象成编译器将代码转换成了：

val iAmFather: IAmFather = originToFather(new IBugOrange(5))

提供原类型外的函数调用

通过上面的例子，可以发现其实就是编译器帮忙生成了一个IAmFather的对象出来，当然这样我们就可以直接调用IAmFather的方法了,像下面这样:

new IBugOrange(6).talk()

当然不是 IBugOrange 拥有 talk() 方法，而是编译器在中间进行了转换：

originToFather(new IBugOrange(6)).talk()

在类上使用 implicit

implicit 可以修饰在 class 上（最外层的class不可以），能让我们很简单的实现装饰器类，简单点说就是在不影响原类的情况下为原类添加更加丰富的函数。

比如我们希望 IAmFather 能够直接飞过月台，少一些蹒跚。

  implicit class IAmFatherPlus(val iAmFather: IAmFather){
    def fly() = {
      print("I will fly!")
      iAmFather.talk()
    }
  }

上面被 implicit 修饰的 IAmFatherPlus 需要一个 IAmFather 对象，意味着当我们在 IAmFather 对象上调用 fly() 方法的时候，编译器会直接帮助我们得到 IAmFatherPlus :

new IAmFather(100).fly()

即实际为：

new IAmFatherPlus(new IAmFather(100)).fly()

所以，得到输出为

I will fly!Stand here(100)!

函数参数上的 implicit

implicit 还有一个比较有意思用法就是可以将其修饰在函数的参数上，当函数调用的作用域中具有匹配类型的隐喻对象或者函数的时候，省去参数的传递，编译器就让函数就使用匹配的内容作为参数。

比如我们 IAmFather 中定义一个 findSonLikeOrange 函数，让 Father 去找他的 Son 喜欢的橘子。

  def findSonLikeOrange(iSonLike: Int)(implicit orangeColorList: List[Int]): Int =
    orangeColorList.count(_ == iSonLike)

可以发现 findSonLikeOrange 有两个参数列表，第一个参数列表中的整型代表儿子喜欢的橘子。第二个参数列表中的 List 代表当下可买的橘子的颜色的列表，使用了 implicit 修饰。

每个儿子都有不同的爱好（有些别扭），但是橘子摊只会有一个。

implicit val originList =  List(1,2,2,3,4,5,6,2,2,1,3,5,6,7)

iAmFather1.findSonLikeOrange(3)
iAmFather2.findSonLikeOrange(3)

我们发现我们不需要显式的将 originList 传递给 findSonLikeOrange 方法，方法也可以正常调用。

提取隐喻内容：

Scala 还提供了一个静态方法,方便我们将添加了 implicit 关键字的对象或者函数方便的提起取出来使用：

def implicitly[T](implicit e: T) = e

可以发现只需要提供想要提取的内容的类型便可。例如提取出上刚才的 List ：

implicitly[List[Int]].length

其他注意项

在同一作用域中，我们不能声明两个同一类型的 implicit。在运行期 Scala 猜不透你想要使用哪一个implicit。
在 2.8 之后，当作用域中的几个隐喻类型在同一条继承结构中，Scala 会选择更加具体的类型。在 2.8 之前， Scala 将会拒绝执行。

总结

虽然简单，写起来也是挺累的。

更多精彩，欢迎关注微信公众号： Funny新青年

Scala - implicit 我去给你买个橘子