扒一扒scala隐式转换

操作规则：

1.作用域，scala编译器将仅考虑作用域之内的隐式转换，要使用某种隐式操作，你必须以单一标识符的形式（一种情况例外）将其带入作用域之内。例如：

object TestImplicit {  implicit def doubleToInt(x: Double) = x.toInt}object test {  def main(args: Array[String]): Unit = {    import layne.impilcit.TestImplicit._//以单一标识符引进doubleToInt的隐式转换    val i: Int = 2.3  }}

单一标识符有一个外例，编译器还将在源类型和目标类型的伴生对象中寻找隐式定义。

2.无歧义，比方说 x+y需要用到隐式转换，但是在作用域内却找到不止一个隐式定义与之匹配，将不能编译通过。

object TestImplicit {  implicit def doubleToInt(x: Double) = x.toInt}object TestImplicit2{  implicit def doubleToInt(x: Double) = x.toInt}object test {  def main(args: Array[String]): Unit = {    import layne.impilcit.TestImplicit._    import layne.impilcit.TestImplicit2._    val i: Int = 2.3//能匹配多个隐式定义，编译将报错  }}

用在何处：

1.转换为期望类型：
在交互模式下直接定义

scala> val i: Int = 3.5<console>:7: error: type mismatch; found : Double(3.5) required: Int  val i: Int = 3.5  ^

将报类型错误
我们定义隐式转换doubleToInt后再重复之前的操作：

scala> implicit def doubleToInt(d: Double) = d.toIntdoubleToInt: (d: Double)Intscala> val i: Int = 3.5i: Int = 3

我们看到Double已经被隐式的转换为我们期望的Int类型。
2.转换接收者
如果你编写了some.doSomething()的代码，而 some中没有定义doSomething方法的话，编译器在放弃之前会尝试插入转换代码。

我们通过一个有理数例子来看看这种转换：

package layne.blog.impilcit/**  * Created by layne on 08/05/17.  */class Rational(val numerator: Int, val denominator: Int) {  require(denominator != 0) //分母为零  def +(rational: Rational): Rational = {    /**      * 最大公约数      *      * @param numerator   分子      * @param denominator 分母      * @return 最大公约数      */    def divisor(numerator: Int, denominator: Int): Int = {      val s = if (numerator > denominator) denominator else numerator      (1 to s).reverse.find(it => numerator % it == 0 && denominator % it == 0).getOrElse(1)    }    val d = divisor(rational.numerator * this.denominator + this.numerator * rational.denominator,      this.denominator * rational.denominator)    Rational((rational.numerator * this.denominator + this.numerator * rational.denominator) / d, this.denominator * rational.denominator / d)  }  override def toString: String = this.numerator + "/" + this.denominator}object Rational {  def apply(numerator: Int, denominator: Int): Rational = new Rational(numerator, denominator)//隐式转换整数为Rational  implicit def intToRational(num: Int) = new Rational(num, 1)}object TestMain extends App {  val oneHalf =  Rational(1, 2)  val rational = 2 + oneHalf  println(rational)}

输出结果为5/2
如果没有隐式转换 们将很难实现 如：2 + oneHalf 的表达式计算，Int类型本身并没有签名为： +(rational: Rational): Rational的方法。而通过隐式转换方法调用者，很轻松完成。

3.作为隐式参数

调用一个带有隐式参数的函数，如果我们不提供显式参数，编译器不会马上报错，在报错之前，编译器会尝试在作用域内寻找单一隐式值（用implicit关键字修饰的参数），用来补充缺失参数:
下例中首先定义一个带隐式参数的函数，我们尝试调用，作用域内没有可以用来补充缺失参数的隐式值

scala> def test(implicit t: String): Unit = println(t)test: (implicit t: String)Unitscala> test<console>:9: error: could not find implicit value for parameter t: String              test              ^

添加一个隐式值，再调用

scala> implicit val s:String = "test"s: String = testscala> testtest

scala> test("test")test

作用域内有多个匹配的隐式值：

scala> implicit val s1:String = "test"s1: String = testscala> test<console>:11: error: ambiguous implicit values: both value s of type => String and value s1 of type => String match expected type String              test              ^

再来看一个稍微复杂一点，用来选出集合内的最大元素的例子：

package layne.blog.impilcitimport scala.concurrent.duration.Deadline/**  * Created by layne on 09/05/17.  */object MaxElement {  def maxElement[T <: Ordered[T]](list: List[T]): T = list match {    case List() => throw new RuntimeException("空集合")    case List(x) => x    case x :: rest => val maxRest = maxElement(rest)      if (x > maxRest) x else maxRest  }  def maxElement2[T](list: List[T])(implicit covert: T => Ordered[T]): T = list match {    case List() => throw new RuntimeException("空集合")    case List(x) => x    case x :: rest => val maxRest: T = maxElement2(rest)(covert)      if (covert(x) > maxRest) x else maxRest  }  def maxElement3[T <% Ordered[T]](list: List[T]): T = list match {    case List() => throw new RuntimeException("空集合")    case List(x) => x    case x :: rest => val maxRest: T = maxElement3(rest)      if (x > maxRest) x else maxRest  }  def main(args: Array[String]): Unit = {    val e1 = Deadline.now    Thread.sleep(1000)    val e2 = Deadline.now    Thread.sleep(1000)    val e3 = Deadline.now    println(maxElement(List(e1, e2, e3)))    println(maxElement2(List("e1", "e2", "e3")))    println(maxElement2(List(1, 2, 3)))  }}

为了能方便的使用 “>”,”<”等操作符，我们让集合内的元素T必须是Ordered[T] 的子类，
但是这样做，我们的大多数基本类型都用不了了，因为scala的基本类型不是Ordered[T]的直接子类。
例如我们如果调用：println(maxElement(List("e1", "e2", "e3")))， 编译时就会有如下错误

Error:(39, 13) inferred type arguments [String] do not conform to method maxElement's type parameter bounds [T <: Ordered[T]]    println(maxElement(List("e1", "e2", "e3")))Error:(39, 28) type mismatch; found   : List[String] required: List[T]    println(maxElement(List("e1", "e2", "e3")))

于是我们想到了隐式参数，maxElement2，因为implicit修饰的是整个参数列表，所以我们需要用柯里化将显示参数和隐式参数分开,scala标准库提供了许多T => Ordered[T]的隐式转换，如：定义在scala.Predef中的implicit def augmentString(x: String): StringOps = new StringOps(x) 让我们能将maxElement2运用在String类型上
因此，我们能把maxElement2，用在许多类型上。

maxElement2也是第三个函数maxElement3中视图界定的原理，不熟悉的小伙伴们可以仔细揣摩一下。

3.隐式类

所谓隐式类就是用implicit 关键字修饰的类(隐式类与样例类互斥即一个类不能同时被implicit和case修饰)
例如：

package layne.blog.impilcit/**  * Created by layne on 09/05/17.  */object ImplicitClass {  implicit class ImplString(string: String) {    def sayHellow = println("hello " + string)  }}object TestMain{  def main(args: Array[String]): Unit = {    def main(args: Array[String]): Unit = {      import layne.blog.impilcit.ImplicitClass._      "jack".sayHellow    }  }}

当 “jack”.sayHellow 时，scala 编译器不会立马报错，而检查当前作用域有没有 用implicit 修饰的，同时可以将String作为参数的构造器，并且具有方法sayHellow的类，经过查找 发现 ImplString 符合要求
利用隐式类 ImplString 执行sayHellow 方法

有了这样的隐式类，我们还能模拟新语法，例如我们创建Map对象：

Map(1 -> "test1",2 -> "test2")

” -> ” 这不是scala内建的语法，只是定义在scala.Predef中的类ArrowAssoc中的方法，感兴趣的同学可以去研究下。

隐式操作的频繁使用会让代码变得晦涩难懂，但是我们要学习scala，乃至查看用scala编写的开源项目如spark，kafka，我们必须熟练这个特性。