scala的隐式转换基本使用

一.什么是隐式转换

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

package imp

object imp01 {
  // 隐式转换
  // 作用：在类型转换的过程中，被自动调用
  // 特点
  // 1. 自动调用
  // 2. 名字不重要，和隐式后面的方法是重要的！

  // Double转Int的隐式转换
  implicit def double2Int(d: Double): Int = {
    println("double2Int被调用了……")
    d.toInt
  }

  // 补充：String转Int的隐式转换
  implicit def string2Int(s: String): Int = {
    println("string2Int被调用了……")
    s.toInt
  }

  def main(args: Array[String]): Unit = {
    // 不能把Double类型 保存到 Int。这样会有精度损失，不会自动转换。
    var i: Int = 1.1
    i = 2.1
    i = 3.1
    // 赋值String类型"100"给Int变量i
    i = "100"

    // 可以把int类型保存到Double，会自动转换
    var c: Double = 1
  }
}

二.隐式函数

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

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

（1）调用时机，在系统自动把数据从类型1隐式转为类型2时出错时，被自动调用。

（2）函数名可以自定义（一般取名为类型1to类型2），但是参数和返回值必须有限制。

package imp

object imp02 {
  // 定义“千米”类
  class KM(var value: Double) {
    override def toString: String = s"${value}千米"
  }

  // 定义“米”类
  class M(var value: Double) {
    override def toString: String = s"${value}米"
  }

  // 隐式转换：KM类型转为M类型（1千米=1000米）
  implicit def km2m(km: KM): M = {
    new M(1000 * km.value)
  }

  def main(args: Array[String]): Unit = {
    val km1 = new KM(1)
    // 利用隐式转换，将KM类型的km1赋值给M类型的m1
    val m1: M = km1

    println(km1)  // 输出：1.0千米
    println(m1)   // 输出：1000.0米
  }
}

三.隐式参数

package imp

object imp03 {
  // 1美元 = 6.9人民币
  // 1人民币 = 0.14美元

  class MY(var value:Double) {
    override def toString: String = s"${value}美元"
  }

  class RMB(var value:Double) {
    override def toString: String = s"${value}人民币"
  }

  // 补充隐式函数：MY转RMB（美元转人民币）
  implicit def my2rmb(my: MY): RMB = {
    new RMB(my.value * 6.9)
  }

  // 补充隐式函数：RMB转MY（人民币转美元）
  implicit def rmb2my(rmb: RMB): MY = {
    new MY(rmb.value * 0.14)
  }

  def main(args: Array[String]): Unit = {
    val m1:RMB = new MY(100)
    println(m1)

    val my1:MY = new RMB(1000)
    println(my1)
  }
}