隐式转换和隐式参数

1）隐式转换

隐式转换函数是以implicit关键字声明的带有单个参数的函数。这种函数将会自动应用，将值从一种类型转换为另一种类型

object Scala01 {

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

    val num1 : Int = 3.5

    val num2 : Int = 4.6

    println(num1)

    println(num2)

}

}

implicit def f1(d: Double): Int = {
    d.toInt
}

//Double 是输入类型, Int 是转换后的类型

隐式函数的底层工作原理

def main(args: Array[String]): Unit = {
     implicit def f1(d: Double): Int = {
         d.toInt
     }

    implicit def f2(l: Long): Int = {
         l.toInt
     }

    val num: Int = 3.5
     println(num)
     val num2: Int = 4.5
     println(num2)
     val num3: Int = 20l
}

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

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

//在当前环境中，不能存在满足条件的多个隐式函数

implicit def a(d: Double) = d.toInt

implicit def b(d: Double) = d.toInt

val i1: Int = 3.5 //（X）在转换时，识别出有两个方法可以被使用，就不确定调用哪一个，所以出错

println(i1)

案例：使用隐式转换方式动态的给MySQL类增加delete方法。

class MySQL{
   def insert(): Unit = {
     println("insert")
   }
}
class DB {
   def delete(): Unit = {
     println("delete")
   }
}
implicit def addDelete(mysql:MySQL): DB = {
       new DB //
}
val mysql = new MySQL
mysql.insert()
mysql.delete()

2）隐式值

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

implicit val str1: String = "jack"
def hello(implicit name: String): Unit = {
     println(name + " hello")
}
hello // 和缺省参数很像, 但是功能不同

object ImplicitVal {
   def main(args: Array[String]): Unit = {
     implicit val str1: String = "jack"
     def hello(implicit name: String): Unit = {
       println(name + " hello")
       def hello(): Unit = {
           println("aaa")
       }
     }
     hello
   }
   def hello(): Unit = {  
     println("bb")
   }
}   

3）隐式类

隐式类使用有如下几个特点：

（1)其所带的构造参数有且只能有一个

（2)隐式类必须被定义在“类”或“伴生对象”或“包对象”里，即隐式类不能是 顶级的(top-level objects)。

（3)隐式类不能是case class（case class在后续介绍 样例类）

（4)作用域内不能有与之相同名称的标识符

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

def main(args: Array[String]): Unit = {
     //DB1会对应生成隐式类
     implicit class DB1(val m: MySQL1) {
       def addSuffix(): String = { //方法
         m + " scala"
       }
     }
     val mysql1 = new MySQL1
     mysql1.sayOk()
     println(mysql1.addSuffix())
}

4）隐式的转换时机

（1)当方法中的参数的类型与目标类型不一致时

（2)当对象调用所在类中不存在的方法或成员时，编译器会自动将对象进行隐式转换（根据类型）

5）隐式解析机制

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

（1)首先会在当前代码作用域下查找隐式实体（隐式方法、隐式类、隐式对象）。

（2)如果第一条规则查找隐式实体失败，会继续在隐式参数的类型的作用域里查找。类型的作用域是指与该类型相关联的全部伴生模块，一个隐式实体的类型T它的查找范围如下(第二种情况范围广且复杂在使用时，应当尽量避免出现)：

    （a) 如果T被定义为T with A with B with C,那么A,B,C都是T的部分，在T的隐式解析过程中，它们的伴生对象都会被搜索。

    （b) 如果T是参数化类型，那么类型参数和与类型参数相关联的部分都算作T的部分，比如List[String]的隐式搜索会搜索List的伴生对象和String的伴生对象。

    （c) 如果T是一个单例类型p.T，即T是属于某个p对象内，那么这个p对象也会被搜索。

    （d) 如果T是个类型注入S#T，那么S和T都会被搜索。

6）隐式转换的前提

在进行隐式转换时，需要遵守两个基本的前提：

（1)不能存在二义性

（2)隐式操作不能嵌套使用