30秒教你隐式转换

object test3 {
  //隐式转换：编译器 偷偷滴：自动帮我们把一种数据转换为另一种类型
  //例如：Int-->Double
  //它有失败的时候（double-->int)有成功的时候
  //当它转换失败的时候，scala提供二次编译的过程我们提供一个工具（implicit修饰的工具）让它能成功
  implicit def X(d:Double):Int={
    println("implicit X 被调用了")
    d.toInt
  }
  def main(args: Array[String]): Unit = {
    var i:Int=1
    var j:Double=2.1
    i=j//把Double装入Int
    println(i)
  }

}

//需求：
//完成一个功能，让所有字符串都能调用isPhone方法，来校检自己是不是一个手机号
object test4 {
  class StrongString(val str: String) {
    def isPhone(): Boolean = {
      val reg = "1[3-9]\\d{9}".r
      reg.matches(str)
    }
    def isID:Boolean={
      val reg="".r
      reg.matches(str)
    }
  }
  implicit def xxxx(str:String):StrongString={
    //println("偷偷调用implicit")
    new StrongString(str)
  }
  def main(args: Array[String]): Unit = {
    //val str="13612345678"
//    println(isPhone(str))
//    println(isPhone("abc"))
    //println((new StrongString(str)).isPhone())
   // println(transform("abc").isPhone())
  //  println(str.isPhone())
    println("136a".isPhone())
  }

}

 

一、隐式参数

//函数的隐式参数
//一直在修改原来的代码
//困难：函数有一个默认参数值，在不传入具体实参时，就会自动使用这个默认值
//难点在于，这个默认值不能改
object test {
  //函数参数的默认值
  def sayName(implicit name:String="小明"):Unit={
    println("我的名字是："+name)
  }
  implicit val value:String="小张"
  def main(args: Array[String]): Unit = {
    sayName("小王")
    //sayName("小花")
    sayName()
    sayName
  }

}

二、隐式类 

//隐式类
//任务：给之前的BaseUser添加新的功能，但是，不要直接去改代码
//思路：把BaseUser通过隐式转换，改成一个新类型，而这个新类型中有这个的新的方法
//implicit class===一个隐式转换函数+类
//它的作用：拓展已有类的功能，而不需要去修改之前类的代码
object test1 {
  implicit class PowerUser (b:BaseUser){
    def updateUser() {
      println("updateUser")
    }

//    def xxxxx(b: BaseUser): PowerUser = {
//      new PowerUser()
    }
  class BaseUser{
    def showUser():Unit={
      println("showUser")
    }
  }
    def main(args: Array[String]): Unit = {
      val u1 = new BaseUser()
      u1.showUser()
      u1.updateUser() //希望要增加的功能
    }

  
}

三，隐式对象

import scala.language.postfixOps
//需求：给一个整数添加一个功能，求阶乘
//5！=1*2*3*4*5=120
object qmks {
  implicit class XXXXX(d:Int){
    def ! :Int={
      println("阶乘函数被调用",d)
      var result = 1
      // 使用for循环从1累乘到当前数字d
      for (i <- 1 to d) {
        result *= i
      }
      result//写代码，完成1*2*3*4*5...*d

    }
  }
  def main(args: Array[String]): Unit = {
    println(5.!)
    println(6!)
    //var i=1

  }


}

//隐式对象
//implicit object
//作用：给函数的隐式参数提供默认值
object test5 {
  case class DatebaseConfig(driver: String,url:String)
  //作为函数的隐式参数的默认值
  implicit object MySqlDefault extends DatebaseConfig("mysql","localhost:443")
  def getConn(implicit config: DatebaseConfig):Unit={
    println(config)
  }
  def main(args: Array[String]): Unit = {
    getConn
  }

}