9.1隐式转换
9.1.1提出问题
先看一段代码，引出隐式转换的实际需要=>指定某些数据类型的相互转化
object Scala01 {
def main(args: Array[String]): Unit = {
val num : Int = 3.5 //?错
val num2:Int = 4.6//? 错 高精度->低精度 ==》1. 强制转换 2. 隐式转换
println(num)
}
}
9.1.2隐式函数基本介绍
隐式转换函数是以implicit关键字声明的带有单个参数的函数。这种函数将会自动应用，将值从一种类型转换为另一种类型
9.1.3隐式函数快速入门
使用隐式函数可以优雅的解决数据类型转换，以前面的案例入门.
代码演示：
object ImplicitDemo {
def main(args: Array[String]): Unit = {
//使用隐式函数
implicit def f1(d:Double): Int = { //底层会生成一个方法 f1$1
d.toInt
}
val n1: Int = 3.4 //=> val n1: Int = f1$1(3.4)
val n2: Int = 5.6
val n3: Int = 1.2
println(n1 + " " + n2 + " " + n3)
}
}
9.1.4隐式转换的注意事项和细节
1)隐式转换函数的函数名可以是任意的，隐式转换与函数名称无关，只与函数签名（函数参数类型和返回值类型）有关。
2)隐式函数可以有多个(即：隐式函数列表)，但是需要保证在当前环境下，只有一个隐式函数能被识别
9.2隐式转换丰富类库功能
9.2.1基本介绍
如果需要为一个类增加一个方法，可以通过隐式转换来实现。（动态增加功能）比如想为MySQL类增加一个delete方法
9.2.2分析解决方案
在当前程序中，如果想要给MySQL类增加功能是非常简单的，但是在实际项目中，如果想要增加新的功能就会需要改变源代码，这是很难接受的。而且违背了软件开发的OCP开发原则 (开闭原则 open close priceple)
在这种情况下，可以通过隐式转换函数给类动态添加功能。
9.2.3快速入门案例
object ImplicitDemo02 {
def main(args: Array[String]): Unit = {
//隐式函数
implicit def addDelete(mySQL: MySQL): DB = {
new DB
}
//创建MySQL对象
val mySQL = new MySQL
mySQL.delete() //底层(编译器做的转换)是这样的: addDelete$1(mySQL).delete()
}
}
//类-insert
class MySQL {
def insert(): Unit = {
println("insert")
}
}
//类 DB-delete
class DB {
def delete(): Unit = {
println("delete...")
}
}
9.3隐式值
9.3.1基本介绍
隐式值也叫隐式变量，将某个形参变量标记为implicit，所以编译器会在方法省略隐式参数的情况下去搜索作用域内的隐式值作为缺省参数
9.3.2应用案例
object ImplicitValDemo01 {
def main(args: Array[String]): Unit = {
//这里的 str1就是隐式值 [=》跑龙套]
implicit val str1: String = "jack"
//说明
//1.implicit name: String 就是一个隐式参数
//2.当调用hello的时候，没有传入实参,则编译器会自动的将隐式值关联到name上
def hello(implicit name: String): Unit = {
println(name + " hello")
}
hello //用到隐式值 底层 hello$1(str1)
}
}
9.4隐式类
9.4.1基本介绍
在scala2.10后提供了隐式类，可以使用implicit声明类，隐式类的非常强大，同样可以扩展类的功能，比前面使用隐式转换丰富类库功能更加的方便，在集合中隐式类会发挥重要的作用。
9.4.2隐式类使用有如下几个特点：
1)其所带的构造参数有且只能有一个
2)隐式类必须被定义在“类”或“伴生对象”或“包对象”里，即隐式类不能是 顶级的(top-level objects)
3)隐式类不能是case class（case class在后续介绍 样例类）
4)作用域内不能有与之相同名称的标识符
9.4.3快速入门案例
object ImplicitClass {
def main(args: Array[String]): Unit = {
//一个隐式类, 可以返回一个隐式类的实例，然后就可以调用隐式类的方法
implicit class DB1(val m: MySQL1) {
def addSuffix(): String = { //方法
m + " scala"
}
def sayHi(): Unit = {
println("sayHi..")
}
def sayHello(): Unit = {
println("hello")
m.sayOk()
}
}
val mySQL = new MySQL1
mySQL.sayOk() //
// 1.底层 DB1$1(mySQL).addSuffix()
// 2. DB1$1(mySQL) 返回的是 ：ImplicitClass$DB1$2 实例
// 3. 通过返回的 ImplicitClass$DB1$2实例.addSuffix()
println(mySQL.addSuffix()) //DB1$1(mySQL).addSuffix()
mySQL.sayHi()
mySQL.sayHello()
}
}
class MySQL1 { //普通类
def sayOk(): Unit = {
println("sayOk")
}
}
9.5隐式的转换时机
1)当方法中的参数的类型与目标类型不一致时
2)当对象调用所在类中不存在的方法或成员时，编译器会自动将对象进行隐式转换（根据类型）
3)案例
object ImplicitChange {
implicit def f2(d: Double): Int = {
d.toInt
}
//作用域,保证隐式转换可以找到..
implicit def f4(cat:Cat): Dog = {
new Dog(cat.name)
}
def main(args: Array[String]): Unit = {
f1(1.1)
var n2: Int = 1.5
val cat = new Cat
f3(cat)
}
def f1(n: Int): Unit = {
println("n=" + n)
}
def f3(dog:Dog): Unit = {
}
}
class Dog(dName:String) {
var name:String = dName
}
class Cat {
var name:String = "tom猫"
}
object T {
//作用域
implicit def f4(cat:Cat): Dog = {
new Dog(cat.name)
}
}
9.6隐式解析机制
9.6.1即编译器是如何查找到缺失信息的，解析具有以下两种规则：
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都会被搜索。
9.7隐式转换的前提
9.7.1在进行隐式转换时，需要遵守两个基本的前提：
1)不能存在二义性
隐式操作不能嵌套使用
