隐式函数

什么是隐式函数

1.implicit 修饰

2.它会自动被调用，当在系统检测到隐式转换失败的时候，去自动调用。

3.函数的名字不重复，重要的是它的输入数据的类型和返回值类型！

作用：偷偷的把一种类型的数据转成另一种类型的数据

案例

把double类型转换成int类型

package regImp

object imp {
  implicit def double2int(d:Double):Int={
    println("调用 duoble2int")
    d.toInt
  }
  def main(args: Array[String]): Unit = {
    var i:Int = 1;
    val d:Double = i
    i=1.2
    i=2.2
    i=3.3
    println(i)
  }
}

如果在写函数的参数的时候，预计某个参数默认值可能会被修改，那么可以设置隐式参数。

package regImp

object imp1 {
implicit val defaultPassword:String ="8888888"
def reg(name:String)(implicit password:String="123456"): Unit ={
  println(s"用户名：${name},密码为：${password}")
}
def main(args: Array[String]): Unit = {
  reg("小花")
  reg("小郭")("123456")
}
}

实例案例

object imp2 {
  class KM(var value: Int) {
    override def toString(): String = s"${value}千米"
  }
  class BM(var value: Int) {
    override def toString(): String = s"${value}百米"
  }
  class M(var value:Double) {
    override def toString(): String = s"${value}米"
  }
  implicit def km2m(km: KM): M = {
    new M(km.value * 1000.0)
  }
  implicit def bm2m(bm: BM): M = {
    new M(bm.value * 10.0)
  }

  def main(args: Array[String]): Unit = {
    val km1 = new KM(2)
    val m1:M=km1
    val m2:M=new BM(2)

    println(km1)
    println(m1)
    println(m2)
  }
}

隐式转换函数的规则

1.无歧视规则 不能写两个相同的函数！

2.不能多次转换

package regImp

object imp2 {
  class KM(var value: Int) {
    override def toString(): String = s"${value}千米"
  }
  class BM(var value: Int) {
    override def toString(): String = s"${value}百米"
  }
  class M(var value:Double) {
    override def toString(): String = s"${value}米"
  }
  implicit def km2m(km: KM): M = {new M(km.value * 1000)}
  implicit def bm2m(bm: BM): M = {new M(bm.value * 10)}

  def main(args: Array[String]): Unit = {
    val km1 = new KM(2)
    //  val m = new M(2)
    val m1:M=km1
    val m2:M=new BM(2)
    
    println(km1)
    println(m1)
    println(m2)

  }
}