9.1 隐式转换

　　9.1.1 提出问题

　　　　　　先看一个案例演示，引出隐式转换的实际需要=>指定某些数据类型的相互转化

object boke_demo01 {

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

    val num: Int = 3.5 //?错 高精度->低精度
    println(num)
  }
}

　　9.1.2 隐式函数基本介绍

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

　　9.1.3 隐式函数快速入门

　　　　　　使用隐式函数可以优雅的解决数据类型转换

　　　　　　案例演示

object boke_demo01 {

  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$1(3.5)
    val num2: Int = 4.5f //
    println("num =" + num)

  }
}

　　　　　　－反编译后的代码

　　　　　　

　　9.1.4 隐式转换的注意事项和细节  

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

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

9.2 隐式转换丰富类库功能 

　　9.2.1 快速入门案例 

　　　　　　使用隐式转换方式动态的给MySql类增加delete方法

　　9.2.2 案例演示 

object boke_demo01 {

  def main(args: Array[String]): Unit = {
    //编写一个隐式函数，丰富mySQL功能
    implicit def addDelete(msql: MySQL): DB = {
      new DB
    }

    //创建mysql对象
    val mySQL = new MySQL
    mySQL.insert()
    mySQL.delete() // 编译器工作 分析 addDelete$1(mySQL).delete()
    mySQL.update()

  }
}

class MySQL {
  def insert(): Unit = {
    println("insert")
  }
}

class DB {
  def delete(): Unit = {
    println("delete")
  }

  def update(): Unit = {
    println("update")
  }
}

9.3 隐式值 

　　9.3.1 基本介绍 

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

　　9.3.2 快速入门案例  

object boke_demo01 {
  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);

  }
}

　　9.3.3 一个案例说明隐式值，默认值，传值的优先级 

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

object boke_demo01 {
  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
  }
}

9.4 隐式类 

　　9.4.1 基本介绍 

　　　　　　在Scala2.10后提供了隐式类，可以使用implicit声明类，隐式类非常强大，同样可以扩展类的功能，比前面使用隐式转换丰富类库功能更加的方便，在集合中隐式类会发挥重要作用

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

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

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

　　　　　　3) 隐式类不能是case class(样例类)

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

　　9.4.3 应用案例 

　　　　　　隐式类的案例，进一步认识隐式类

object boke_demo01 {

  def main(args: Array[String]): Unit = {
    //DB会对应生成隐