scala的隐式转换基本使用

（一）什么是隐式转换

隐式转换是指：scala自动把一种类型转成另一种类型的过程。这个过程对用户编程而言不可见，不需要用户手动编写代码。

（二）隐式函数

在scala.Predef中，可以看到有系统提供了默认的情况。

隐式函数的定义：通过implicit关键字修饰的函数，它的功能是把一种类型的数据转成另一种类型。

package imp

object imp01 {
implicit def doubleToInt(x:Double):Int={
  println("double to int...")
  x.toInt
}

  def main(args: Array[String]): Unit = {
    //1隐式转换
    var i:Int = 1;

    var d:Double = 1.1;

    d = i //把int→double类型

    //d =i.toDouble
    //println(s"d=${d}")

    i=d // 存在一个隐式转换 把 double→int 报错!!!
    i=100.1
    i=100.1
  }
}

（三）隐式参数 如果一个函数有多个参数，并且你只想对某个参数进行隐式转换，那么，可以使用柯里化的方式来定义参数，并且把转换的参数定义在参数列表的最后。

package imp

//在写代码的过程中，有一个原则：尽量不要修改之前的代码
//隐式参数
//在开发过程中，如果预判一个参数奖励会变动，就可以把它设置为implicit

object imp02 {
  implicit val abc:String="88888888"
  def reg(name:String)(implicit password:String="123456"):Unit={
    println(s"注册成功，姓名：${name},密码：${password}")
  }
// def reg(name:String,password:String="123456"):Unit={
//  println(s"注册成功，姓名：${name},密码：${password}")
//}

  def main(args: Array[String]): Unit = {

    reg("小花")//没有传入密码，使用·默认值123456
    reg("小白")("admin")
  }
}

（四）转换规则

具体来说有两点：无歧义规则，不能多次转换。

package imp

//隐私转换规则
//1.无歧义规则。不能重新定义两个相同的转换函数
//2.不能多次转换
//在一次转换中，A→B，B→C。不能把A→C

object imp03 {
  class KM(var value:Double){override def toString=s"${value}千米"}
  class BM(var value:Double){override def toString=s"${value}百米"}
  class M(var value:Double){override def toString=s"${value}米"}


  implicit def km2bm(km: KM):BM = new BM(km.value*10)
  implicit def bm2m(bm: BM):M = new M(bm.value*100)
  implicit def km2m(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)
  }
}

（五）作用域

implicit 不能放在顶级作用域（不能放在类的外边）看如下代码，就会报错

在实际的操作过程中，我们建议把它定义在如下两个地方： 1.包对象。这样在这个包下的所有类和对象中都可以使用，并且不需要额外的引入语句。

2. 一个单独的文件定义中。这样在其他需要的位置就可以直接导入，然后使用。