object boke_demo01 {
 
  def main(args: Array[String]): Unit = {
 
    val num: Int = 3.5 //?错 高精度->低精度
    println(num)
  }
}

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)
 
  }
}

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")
  }
}

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);
 
  }
}

//小结
//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
  }
}

object boke_demo01 {
 
  def main(args: Array[String]): Unit = {
    //DB会对应生成隐式类
    //DB是一个隐式类, 当我们在该隐式类的作用域范围，创建MySQL实例
    //该隐式类就会生效, 这个工作仍然编译器完成
    //看底层..
    implicit class DB(val m: MySQL) { //boke_demo01$DB$1
      def addSuffix(): String = {
        m + " scala"
      }
    }
 
 
    //创建一个MySQL实例
    val mySQL = new MySQL
    mySQL.sayOk()
    mySQL.addSuffix() //研究 如何关联到 DB$2(mySQL).addSuffix();
 
    implicit def f1(d: Double): Int = {
      d.toInt
    }
 
    def test(n1: Int): Unit = {
      println("ok")
    }
 
    test(10.1)
 
  }
}
 
class DB {}
 
 
class MySQL {
  def sayOk(): Unit = {
    println("sayOk")
  }
}

implicit def f1(d: Double): Int = {
      d.toInt
}
 
def test1(n1: Int): Unit = {
      println("ok")
}
 
test1(9.1)

object boke_demo01 {
  def main(args: Array[String]): Unit = {
 
    //1. 隐式转换不能有二义性
    //2. 隐式转换不能嵌套使用
 
    implicit def f1(d: Double): Int = {
      d.toInt
      //val num2:Int = 2.3 //底层 f1$1(2.3) //f1$1对应的就是f1,就会形成递归
    }
 
    val num1: Int = 1.1
  }
}