scala的隐式转换基本使用

1.什么是隐式转换隐式转换：

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

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
  }
}

在上面的代码的过程中，scala就帮我们做了一次隐式转换:把Int -> Double。

2.隐式函数

1.用关键字implicit修

2.它的函数名不重要（），重要的是它的 参数和返回值的 类型

3.系统会自动调用它

注意：不能写两个同类型（参数和返回值类型都一样）的隐式转换函数，他就会报错！！！

它的参数是Double， 它的返回值是Int，它的作用是：当代码中出现了需要把Double转换成Int的时候，系统会自动调用它

package imp

object imp01 {
  /*
  隐式转换
  1.用关键字implicit修饰
  2.它的函数名不重要（），重要的是它的 参数和返回值的 类型
  3.系统会自动调用它

  注意：不能写两个同类型（参数和返回值类型都一样）的隐式转换函数，他就会报错！！！

  它的参数是Double， 它的返回值是Int，它的作用是：当代码中出现了需要把Double转换成Int的时候，系统会自动调用它
   */
  implicit def doubleToInt(x:Double):Int = {
    println("double to int ...")
    x.toInt
  }
  /*
  implicit def xxx(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
  }
}

3.隐式参数

在写代码的过程中，有一个原则：尽量不要修改之前的代码

在开发过程中，如果预判一个参数将来会变动，就可以把它设置为implicit

package imp
//在写代码的过程中，有一个原则：尽量不要修改之前的代码
//隐式参数
//在开发过程中，如果预判一个参数将来会变动，就可以把它设置为implicit
object imp02 {
  implicit val defaultPassword: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("小花")
    reg("小白")("admin")
  }
}

4.隐私转换规则

1.无歧义规则。不能重新定义两个相同的转换函数

2.不能多次转换

在一次转换中，A → B，B → C，不能 A → C

package imp

//隐私转换规则
//1.无歧义规则。不能重新定义两个相同的转换函数
//2.不能多次转换
//在一次转换中，A → B，B → C，不能 A → C
object imp03 {
  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)

  //_______________________________

  def main(args: Array[String]):Unit = {
    val km = new KM(1.1)
    val bm:BM = km
    println(km)
    println(bm)

5.隐式转换函数的书写位置

6.隐式类

背景：有一个现成的类，它有一个方法，我们现在需要对这个类的功能进行拓展:额外补充一个新方法

但是：不允许直接修改原来的代码

思路：补充一个新的类，把这个新的方法写到这个类中

/*
隐式类
背景：有一个现成的类，它有一个方法，我们现在需要对这个类的功能进行拓展:额外补充一个新方法
但是：不允许直接修改原来的代码
思路：
1.补充一个新的类，把这个新的方法写到这个类中
2.补充一个隐式转换函数，把这个旧类转成这个新类
 */

object imp05 {
  class User {
    def insertUser():Unit = {
      println("添加一个新用户....")
    }
  }

  class UserExt {
    def updateUser():Unit = {
      println("修改用户 .....")
    }
  }

  implicit def XXX(user: User):UserExt = {
    new UserExt
  }
  def main(args: Array[String]):Unit = {
    val u1 = new User()
    u1.insertUser()

    u1.updateUser()
  }
}