什么是隐式转换
隐式转换是指：scala自动把一种类型转成另一种类型的过程。这个过程对用户编程而言不可见，不需要用户手动编写代码。
请大家一起回顾如下代码
val b:Byte = 10;
val i:Int = b
在上面的代码的过程中，scala就帮我们做了一次隐式转换:把Int -> Double。
隐式函数
在scala.Predef中，可以看到有系统提供了默认的情况。
隐式函数的定义：通过implicit关键字修饰的函数，它的功能是把一种类型的数据转成另一种类型。
implicit def 函数名(参数：类型1)：类型2 = {
函数体
}
注意点：
（1）调用时机，在系统自动把数据从类型1隐式转为类型2时出错时，被自动调用。
（2）函数名可以自定义（一般取名为类型1to类型2），但是参数和返回值必须有限制。
例子：
package imp
object imp1 {
// 隐式转换函数
// 1.用关键字implicit修饰
// 2.它的函数名不重要（）,重要的是它的参数和返回值的类型
// 3.系统会自动调用它
//注意：不能写两个同类型（参数和返回值的类型都一样）的隐式转换函数，他会报错！
// 它的参数是Double,它的返回值是Int，它的作用是：Double转换Int的时候， 系统会调用它
implicit def abc(x:Double):Int={
println("double to int...")
x.toInt
}
def main(args: Array[String]): Unit = {
var i:Int=1;
var d:Double=1.1;
d=1 //把int → double类型，它会自动也去调用隐式转换函数
//d=i.toDouble
//println(s"d=${d}")
i=d //存在一个隐式转换 把doubl → int报错!!
i=100.1
i=100.1
}
}
转换规则
隐式转换确实非常的强大，但是，在具体的使用过程中，我们要遵循一些特定的转换规则。
具体来说有两点：无歧义规则，不能多次转换。下面我们分别来解释
规则1：无歧义规则：不能重新定义两个相同的转换函数。如果有两个隐式转换函数，只有函数名不同，则会导致错误。
规则2：不能多次转换：在一次转换过程中可以把A->B，B->C，但是不能直接从A->C。来通过具体的代码来说明。
package imp
//隐私转换规则
//1.无歧义规则。不能重新定义两个相同
object imp3 {
class KM(var value:Double){override def toString:String=s"${value}千米"}
class BM(var value:Double){override def toString:String=s"${value}百米"}
class M(var value:Double){override def toString:String=s"${value}米"}
implicit def km2bm(km:KM):BM=new BM(km.value*10)
implicit def bm2bm(bm:BM):M=new M(bm.value*100)
implicit def m2m(km:KM):M=new M(km.value*1000)
def main(args: Array[String]): Unit = {
val km=new KM(1.1)
val bm:BM=km
println(km)
println(bm)
val m:M=bm
println(m)
val m1:M=new KM(2)
println(m1)
}
}
