[toc]
## Scala隐式转换和隐式值
先看一段代码，引出隐式转换的实际需要：指定某些数据类型的相互转化
~~~scala
object ScalaConversionDemo01 {
def main(args: Array[String]): Unit = {
//var num:Int = 3.5 //error 高精度->低精度
//println(num)
}
}
~~~
#### 隐式转换
> 1. `隐式转换函数是以implicit关键字声明的带有单个参数的函数`。这种函数将会自动应用，将值从一种类型转换为另一种类型
> 2. 使用隐式函数可以优雅的解决数据类型转换，以前面的案例入门
~~~~scala
/**
* @Date 2021/3/31 16:12
* @Version 10.21
* @Author DuanChaojie
*/
object ScalaConversionDemo01 {
def main(args: Array[String]): Unit = {
//var num:Int = 3.5 //error 高精度->低精度
//println(num)
/**
* 隐式转换函数，隐式函数应当在作用域才能生效
*
* @param double —> Int
* @return Int
*/
implicit def fun1(double: Double): Int = {
double.toInt
}
// 底层编译 fun$(3.5)
val num1: Int = 3.5
println(num1)
}
}
~~~~
> 反编译后的代码：`ScalaConversionDemo01$`
~~~~java
public final class ScalaConversionDemo01${
public static final MODULE$;
static{
new ();
}
public void main(String[] args){
int num = fun$1(3.5D);
Predef..MODULE$.println(BoxesRunTime.boxToInteger(num));
}
private final int fun$1(double double){
return (int)double;
}
private ScalaConversionDemo01$(){
MODULE$ = this;
}
}
~~~~
> 隐式转换的注意事项和细节：
>
> 1. 隐式转换函数的函数名可以是任意的，`隐式转换与函数名称无关`，只与函数签名（函数参数类型和返回值类型）有关。
> 2. 隐式函数可以有多个(即：隐式函数列表)，但是需要保证在当前环境下，只有一个隐式函数能被识别。
~~~~scala
package com.atguigu.chapter09
/**
* @Date 2021/3/31 16:12
* @Version 10.21
* @Author DuanChaojie
*/
object ScalaConversionDemo01 {
def main(args: Array[String]): Unit = {
//var num:Int = 3.5 //error 高精度->低精度
//println(num)
/**
* 隐式转换函数，隐式函数应当在作用域才能生效
*
* @param double —> Int
* @return Int
*/
implicit def fun1(double: Double): Int = {
double.toInt
}
// 底层编译 fun$(3.5)
val num1: Int = 3.5
println(num1)
implicit def fun2(float: Float): Int = {
println("fun2执行了....")
float.toInt
}
val num2: Int = 4.6f
println(num2)
}
}
~~~~
> 隐式转换丰富类库功能
>
> - 如果需要为一个类增加一个方法，可以通过隐式转换来实现。（动态增加功能）比如想为MySQL类增加一个delete方法
```scala
/**
* @Date 2021/3/31 16:22
* @Version 10.21
* @Author DuanChaojie
*/
object ScalaImplicitDemo02 {
def main(args: Array[String]): Unit = {
/**
* 隐式函数，丰富MYSQL功能
* @param mysql
* @return
*/
implicit def addDelete(mysql: MySQL): DB = {
new DB
}
// 创建mysql对象
val mysql = new MySQL
mysql.insert()
// 编译器工作，addDelete$1(mysql).delete()
mysql.delete()
mysql.update()
}
}
class MySQL {
def insert(): Unit = {
println("insert")
}
}
class DB {
def delete(): Unit = {
println("delete")
}
def update(): Unit = {
println("update")
}
}
class Dog {
}
```
#### 隐式值
> 隐式值也叫隐式变量，将某个形参变量标记为implicit，所以编译器会在方法省略隐式参数的情况下去搜索作用域内的隐式值作为缺省参数
~~~scala
/**
* @Date 2021/3/31 16:27
* @Version 10.21
* @Author DuanChaojie
*/
object ScalaImplicitValDemo01 {
def main(args: Array[String]): Unit = {
// 这个就是隐式值
implicit val str: String = "tom"
def hello(implicit name:String): Unit ={
println(name + "~ hello")
}
// 底层hello$1.(str)
hello
}
}
~~~
> `隐式值，默认值，传值的优先级`
~~~~scala
/**
* @Date 2021/3/31 16:39
* @Version 10.21
* @Author DuanChaojie
*/
object ScalaImplicitValDemo02 {
/**
* 小结
* 1. 当在程序中，同时有 隐式值，默认值，传值
* 2. 编译器的优先级为 传值 > 隐式值 > 默认值
* 3. 在隐式值匹配时，不能有二义性
* 4. 如果三个 （隐式值，默认值，传值） 一个都没有，就会报错
*
* @param args
*/
def main(args: Array[String]): Unit = {
//test1() error 因为在隐式值匹配时，不能有二义性
test2() //Hello Scala
test3() //hello jack
// test4() // error
}
def test1(): Unit = {
// 隐式变量（值）
implicit val name: String = "Scala"
//implicit val name1: String = "World"
def hello(implicit content: String = "jack"): Unit = {
println("Hello " + content)
}
//调用hello
hello
}
def test2(): Unit = {
// 隐式遍历
implicit val name: String = "Scala"
//当同时有implicit 值和默认值，implicit 优先级高
def hello2(implicit content: String = "jack"): Unit = {
println("Hello " + content)
}
//调用hello
hello2
}
def test3(): Unit = {
//当一个隐式参数匹配不到隐式值，仍然会使用默认值
implicit val name: Int = 10
def hello3(implicit content: String = "jack"): Unit = {
println("Hello " + content)
}
//调用hello
hello3
}
def test4(): Unit = {
//当没有隐式值，没有默认值，又没有传值，就会报错
def hello4(implicit content: String): Unit = {
println("Hello4 " + content)
}
//调用hello
// hello4 error
}
}
~~~~
#### 隐式类
> `在Scala2.10后提供了隐式类`，可以使用implicit声明类，隐式类的非常强大，同样可以扩展类的功能，比前面使用隐式转换丰富类库功能更加的方便，在集合中隐式类会发挥重要的作用。
>
> 隐式类使用有如下几个特点：
>
> 1. 其所带的构造参数有且只能有一个。
> 2. 隐式类必须被定义在`“类”`或`“伴生对象”`或`“包对象”`里，`即隐式类不能是 顶级的(top-level objects)。`
> 3. 隐式类不能是case class（case class在后续介绍 样例类）
> 4. 作用域内不能有与之相同名称的标识符。
```scala
/**
* @Date 2021/3/31 16:49
* @Version 10.21
* @Author DuanChaojie
*/
object ImplicitClassDemo {
def main(args: Array[String]): Unit = {
/**
* DB1会对应生成隐式类
* DB1是一个隐式类, 当我们在该隐式类的作用域范围，创建MySQL1实例
* 该隐式类就会生效, 这个工作仍然编译器完成
* 看底层.. //ImplicitClassDemo$DB1$2
*/
implicit class DB1(val m: MySQL1) {
def addSuffix(): String = {
m + " scala"
}
}
val mysql1 = new MySQL1
mysql1.sayOk()
//如何关联到 DB1$1(mySQL).addSuffix();
mysql1.addSuffix()
}
}
class DB1 {}
class MySQL1 {
def sayOk(): Unit = {
println("sayOk")
}
}
```
#### 隐式的转换时机
> 1. 当方法中的参数的类型与目标类型不一致时。
> 2. 当对象调用所在类中不存在的方法或成员时，编译器会自动将对象进行隐式转换（根据类型）。
>
> 隐式解析机制：
>
> 即编译器是如何查找到缺失信息的，解析具有以下两种规则：
>
> 1. 首先会在当前代码作用域下查找隐式实体（隐式方法、隐式类、隐式对象）。(一般是这种情况)
> 2. 如果第一条规则查找隐式实体失败，会继续在隐式参数的类型的作用域里查找。类型的作用域是指与该类型相关联的全部伴生模块，一个隐式实体的类型T它的查找范围如下(第二种情况范围广且复杂在使用时，应当尽量避免出现)：
> 1. 如果T被定义为T with A with B with C,那么A,B,C都是T的部分，在T的隐式解析过程中，它们的伴生对象都会被搜索。
> 2. 如果T是参数化类型，那么类型参数和与类型参数相关联的部分都算作T的部分，比如List[String]的隐式搜索会搜索List的伴生对象和String的伴生对象。
> 3. 如果T是一个单例类型p.T，即T是属于某个p对象内，那么这个p对象也会被搜索。
> 4. 如果T是个类型注入S#T，那么S和T都会被搜索。
>
> 在进行隐式转换时，需要遵守两个基本的前提：
>
> 1. 不能存在二义性
> 2. 隐式操作不能嵌套使用 `// [举例：]如:隐式转换函数`
## ☆