Scala 隐式转换

一、隐式转换

隐式转换需要执行隐式函数，隐式函数是以 implicit 关键字声明的带有单个参数的函数。
隐式函数会根据需要自动被调用，将值从一种类型转换为另一种类型。

// 隐式转换，将 Double 转为 Int
object ImplicitDemo1 {
  def main(args: Array[String]): Unit = {
    // 隐式函数
    implicit def double2Int(d: Double): Int = { d.toInt }
    var a: Int = 3.9
    println(a)
  }
}

注意：

1. 隐式转换函数的函数名可以是任意的，隐式转换与函数名无关，只与函数参数类型和返回值类型有关。
2. 隐式函数可以有多个（即：隐式函数列表），但是要保证在当前环境下，只有一个隐式函数能被识别。

二、利用隐式转换函数丰富现有类库

设想 如果 java.io.File 能有个 read() 方法直接读取文件就好了, 我们可通过隐式转换给 File 类添加一个 read() 方法。

object ImplicitDemo2 {
  def main(args: Array[String]): Unit = {
    // 隐式转换函数，给 java.io.File 添加一个 read 方法
    implicit def file2RichFile(from: File): RichFile = new RichFile(from)
    val path = "D:\\workspace\\workspace_idea\\scala-maben\\src\\main\\scala\\com\\atguigu\\scalamaben\\day05\\implicitdemo\\ImplicitDemo1.scala"
    val content = new File(path).read
    println(content)
  }
}
// 该类中存所需要的方法
class RichFile(file: File) {
   // 真正调用的方法
  def read = Source.fromFile(file.getPath).mkString
}

三、隐式值

隐式值也叫隐式变量（包括隐式形参），将某个形参变量标记为 implict，编译器会在方法省略隐式参数的情况下去搜索作用域内的隐式值作为缺省参数。

object ImplicitDemo3 {
  // 隐式变量
  implicit var name: String = "jack"
  def main(args: Array[String]): Unit = {
    hello("hehe")   // hehe你好
    // 当没有传递参数的时候，会找类型为 String 的隐式变量
    hello   // jack你好
  }
  // 隐式参数
  def hello(implicit name: String): Unit = {
    val str: String = name + "你好"
    println(str)
  }
}

注意：

1. 在调用函数时，如果想使用隐式值就不能试用括号
2. 当匹配到多个隐式值时就会报错
3. 隐式参数要和其他参数分开，放在一个参数列表中

四、隐式类

在 Scala 2.10 后提供了隐式类，可以使用 implict 声明类。
隐式类的特点：

1. 其所在的构造函数有且只有一个
2. 隐式类必须定义在“类”或者“伴生对象”或“包对象”里，即隐式类不能是顶级的（top-level objects）
3. 隐式类不能是 case class 样例类
4. 作用域内不能有与之相同的标识符
   隐式类可以看做是隐式转换函数的语法糖

object ImplicitDemo1 {
  def main(args: Array[String]): Unit = {
    // Object 中定义了一个隐式类，这里就不用声明 隐式转换函数了，下面的 new File() 会自己寻找隐式类，查找 read() 方法。
    // implicit def File2RichFile(file: File): RichFile = new RichFile(file)

    val path = "D:\\workspace\\workspace_idea\\bigdata-interview\\src\\main\\scala\\com\\maben\\bigdata\\interview\\coding\\implicitd\\ImplicitDemo1.scala"
    val content = new File(path).read

    println(content)

  }
  // 该隐式类在 Object 内部，加上 implicit 
  implicit class RichFile(file: File) {
    def read: String = Source.fromFile(file.getPath).mkString
  }
}

隐式类的灵活与方便

object ImplicitDemo2 {
  def main(args: Array[String]): Unit = {


    val mysql1: Mysql = new Mysql
    mysql1.sayOK()     // Mysql 类型 调用自己的 sayOK 方法
    mysql1.addSuffix()    // Mysql 类型，自己没有 addSuffix 方法，隐式类有，调用隐式类的

    val mysql2: DB1 = new Mysql
    mysql2.sayOK()    // DB1 类型，默认调用隐式类的 sayOK 方法
    mysql2.addSuffix()    // DB1 类型，默认调用隐式类的 addSuffix 方法
  }

  // 隐式类，接收 Mysql 类型的参数，即 Msyql 的对象可以调用该类中的方法
  implicit class DB1(var m: Mysql) {
    def sayOK(): Unit = println("db1 sayOK...")
    def addSuffix(): Unit = println( m + " scala")
  }
}
class Mysql {
  def sayOK(): Unit = println("sayOk...")
  override def toString: String = "mysql1-toString..."
}
-------------------------- 输出结果 ---------------------------
sayOk...
mysql1-toString... scala
db1 sayOK...
mysql1-toString... scala

五、隐式转换的时机

1. 当方法中的参数类型与目标类型不一致时
2. 当对象调用所在类中不存在的方法或者成员时，编译器会自动将对象进行隐式转换（根据类型）

六、隐式转换的前提

1. 不能存在二义性
2. 隐式操作不能嵌套

七、隐式转换的查找

编译器在查找隐式转换时会有两种规则：

1. 首先会在当前代码作用域下查找隐式实体（隐式方法、隐式类、饮食对象）（一般都是这种情况）
2. 如果第一条查找失败，会到相关类型的伴生对象中查找。