扒一扒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.toInt
doubleToInt: (d: Double)Int

scala> val i: Int = 3.5
i: 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)Unit
scala> test
<console>:9: error: could not find implicit value for parameter t: String
              test
              ^

添加一个隐式值，再调用

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

scala> test
test

scala> test("test")
test

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

scala> implicit val s1:String = "test"
s1: String = test

scala> 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.impilcit

import 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，我们必须熟练这个特性。