Scala 隐式转换、隐式值、隐式类、隐式转换时机、使用规则

---

概述

隐式转换和隐式参数是Scala中非常有特色的功能，也是Java等其它编程语言没有的功能。我们可以很方便的利用隐式转换来丰富现有类的功能。在编写Akka并发编程，Spark，Flink程序时都会经常用到它们。

• 隐式转换：指的是用 implicit 关键字，声明的带有单个参数的方法。
• 隐式参数：指的是用 implicit 关键字修饰的变量。

注意：implicit 关键字是在 Scala 的 2.10版本出现的。

---

隐式转换

所谓隐式转换，是指以 implicit 关键字声明的带有单个参数的方法。该方法是被 自动调用 的。用来实现 自动将某种类型的数据转换为另外一种类型的数据。

使用注意事项

1. 在 object单例对象 中定义隐式转换方法.

   隐式转换方法解释: 就是用implicit关键字修饰的方法.

2. 在需要用到隐式转换的地方, 引入隐式转换.

   类似于 导包 , 通过 import关键字实现 .

3. 当需要用到 隐式转换方法 时, 程序会自动调用

4. 隐式转换函数的函数名可以是任意的，隐式转换与函数名无关，只与函数签名（函数参数类型和返回值类型）有关。

5. 隐式函数可以有多个（即：隐式函数列表），但是需要保证在当前环境下，只有一个隐式函数能被识别。

代码演示：

object ImplicitDemo01 {
     

  def main(args: Array[String]): Unit = {
     
    //编写一个隐式函数转成 Double->Int 转换，隐式函数应当在作用域才能生效、
    implicit def f1(d: Double):Int = {
       //底层生成 f1$1
      d.toInt
    }

    implicit def f2(f: Float):Int = {
     
      f.toInt
    }

    //这里必须保证隐式函数的匹配只能是唯一的
//    implicit def f3(f1: Float):Int = {
     
//      f1.toInt
//    }

    val num: Int = 3.5  //底层编译 f1$(3.5) //idea_
    println("num = " + num)
    val num2: Int = 4.5f
    println("num2 = " + num)
  }

}

num = 3
num2 = 3

Process finished with exit code 0

---

隐式值

隐式值也叫隐式变量，将某个形参变量标记为 implicit，所以编译器会在方发省略隐式参数的情况下去搜索作用域内的隐式值作为缺省参数。

代码：

object 隐式值 {
     

  def main(args: Array[String]): Unit = {
     
    implicit val str1: String = "jack~"  //银式值

    //implicit name: String   //name就是隐式值
    def hello(implicit name: String):Unit = {
     
      println(name + "hello")
    }

    hello //底层 hello$1(str1)
  }

}

jack~hello

Process finished with exit code 0

隐式值，默认值，传值 优先级比较

1. 当在程序中，同时有 隐式值，默认值，传值
2. 编译器的优先级为：传值 > 隐式值 > 默认值
3. 在隐式值匹配时，不能有二义性
4. 如果三个（隐式值，默认值，传值） 一个都没有，就会报错

代码演示：

object 隐式值案例 {
     

  def main(args: Array[String]): Unit = {
     
    //隐式变量（值）
    //implicit val name: String = "Scala"
    implicit val name1: String = "World"

    //隐式参数
    def hello(implicit content: String="jack"): Unit = {
     
      println("Hello" + content)
    } //调用 hello
    hello //使用隐式值不要带()

    //当同时有 implicit值和默认值，implicit优先级高
    def hello2(implicit content: String = "jack"): Unit = {
     
      println("Hello2" + content)
    } //调用 hello
    hello2

    //说明
    //1. 当一个隐式参数匹配不到隐式值，仍然会使用默认值
    implicit val name: Int = 10
    def hello3(implicit content: String = "jack"): Unit = {
     
      println("Hello3" + content)
    } //调用hello
    hello3  //hello3 jack

    //当没有隐式值，没有默认值，又没有传值，就会报错
    def hello4(implicit content: String): Unit = {
     
      println("Hello4" + content)
    } //调用hello
    hello4  //hello3 jack
  }

}

HelloWorld
Hello2World
Hello3World
Hello4World

Process finished with exit code 0

---

隐式类

1. 隐式类所带的构造参数有且只能有一个
2. 隐式类必须被定义在 “类” 或 “伴生对象” 或 “包对象” 里，即隐式类不能是顶级的（要考虑到作用域的问题）
3. 隐式类不能是 case class（样例类）。
4. 作用域内不能有与之相同名称的标识符。

代码演示：

object 隐式类 {
     

  def main(args: Array[String]): Unit = {
     
    /*DB1 会对应生成隐式类
      DB1 是一个隐式类，当我们在改隐式类的作用域范围，创建MySQL1实例
      该隐式类就会生效，这个工作仍然是编译器完成
    */
    implicit class DB1(val m: MySQL1) {
      //隐式类$DB1$2
      def addSuffix():String = {
     
        m + "scala"
      }
    }

    //创建一个MySQL1实例
    val mySQL = new MySQL1
    mySQL.sayOK()
    mySQL.addSuffix()
  }
}

class DB1 {
     }

class MySQL1 {
     
  def sayOK(): Unit = {
     
    println("sayOK")
  }
}

sayOK

Process finished with exit code 0

如上代码，当实例化MySQL1类的时候，就会发生隐式转换，该隐式类就会生效。

---

隐式转换时机

1. 当方发中的参数类型与目标类型不一致时，或者是赋值时，会发生隐式转换。如下代码所示。
   
2. 当对象调用所在类中不存在的方发或成员时，编译器会自动将对象进行隐式转换（根据类型）。

---

隐式解析机制

编译器是如何查找到缺失信息的，解析具有以下俩种规则：

• 1.首先会在当前代码作用域下查找隐式实体（隐式方发、隐式类、隐式对象）
• 2.如果第一条规则查找隐式实体失败，会继续在隐式参数的类型的作用域里查找。类型的作用域是指与该类型相关联的全部伴生模块，一个隐式实体的类型T它的查找范围如下（第二种情况范围广且复杂在使用时，应当尽量避免出现）
  • (1) 如果T被定义为 T with A with B with C，那么A，B，C都是T的部分，它们的伴生对象都会被搜索。
  • (2) 如果T是参数化类型，那么类型参数和类型参数想关联的部分都算作T的部分，比如 List[String] 的隐式搜索会搜索 List 的伴生对象和 String 的伴生对象。
  • (3) 如果T是一个单例类型 p.T，即T是属于某个p对象内，那么这个p对象也会被搜索。
  • (4) 如果T是个类型注入S#T，那么S和T都会被搜索。

---

隐式转换使用规则

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