Scala:隐式转换

隐式转换的定义

//隐式转换：编译器自动滴，偷偷滴，把数据A->B
object test04 {
  def main(args: Array[String]): Unit = {
    val i:Int=1
    //把Int类型，转化成Double类型
    //Int -> Double
    //隐式转换失败
    val b:Double=1
    //隐式转换失败
    val d:Double=1.2
    val j:Int=d
  }
}

object test05 {
  def main(args: Array[String]): Unit = {
    //小明
    def getAge():Double={
      19.5
    }
    
    implicit def abc(d:Double):Int={
      d.toInt
    }
    //implicit  隐式转换
    //函数
    def main(args: Array[String]): Unit = {
//      val i:Int=doubleToInt(getAge())
      val i:Int=getAge()
      println(i)
    }
  }
}

隐式值

//隐式值
object test06 {
  //函数的默认参数
  //函数的默认参数值：小花
  def sayName(implicit name:String="小花"):Unit={
    println(s"我叫：$name")
  }
  //需求：更改函数参数的默认值(不传入这个值的时候，用到的值)，不要写死
  //步骤：
  //1.定义函数的默认值时，添加implicit
  //2.需要修改这个默认值是，定义一个同类型的 隐式值：implicit 修饰变量
  implicit val xxx:String="小明"
  def main(args: Array[String]): Unit = {
    sayName("无敌小旋风")
    sayName
    sayName
  }
}

给字符串添加新的功能 

object test07 {
  //目标：给字符串添加新的功能
  //用到了：implicit 函数+普通类StrongString
  implicit class StrongString(str:String) {
    def isPhone: Boolean = {
      val reg = "1[3-9]\\d{9}".r
      reg.matches(str)
    }
  }
//  implicit def stringtoStrongString(str:String):StrongString={
//    new StrongString(str)
//  }

  def main(args: Array[String]): Unit = {
    val str:String="13612345678"

    //要求：给字符串补充一个功能 isPhone,判断它是不是一个手机号码
    val rs=str.isPhone
//    val rs=(new StrongString(str))isPhone
//      val rs=stringtoStrongString(str).isPhone
    println(s"$str 的检查结果是：$rs")
  }
}

 

 给所有整数添加新功能

import scala.language.postfixOps
//给所有的整数添加新功能
//1.判断是否偶数
//2.阶乘。5！=5*4*3*2*1=120
object test10 {
  implicit class XXX(d:Int){
    def isEven:Boolean={
      d % 2 == 0
    }
    //补充一个求阶乘的函数。函数的名称就是i
    def ! : Int={
      var rs = 1
      for(i<-1 to d){
        rs *= i
      }
      rs
    }
  }
  def main(args: Array[String]): Unit = {
    println(10.isEven)//true
    println(9.isEven)//false
    println(5!)//120
    println(5.!)//120
    println(10!)//3628800
  }
}

 

隐式对象

//隐式对象
//格式：implicit object
//作用：给函数的默认参数提供隐式值
object test11 {
  case class DataBase(driver:String,url:String)
  implicit object mySql extends DataBase("mySql","localhost:300")
  def getConn(implicit config:DataBase):Unit=
    println(config)
  def main(args: Array[String]): Unit = {
//    println()
    getConn(DataBase("sqlite","localhost:80"))
    getConn//采用默认值
  }
}