(一）隐式对象
隐式对象是一个带有implicit关键字的单例对象，它可以用于提供某种类型的实例以供隐式转换使用。隐式对象通常用于将某个类或trait的实例隐式地注入到方法中。
case class DatabaseConfig( driver: String, url: String)
implicit object MySqlDefaultConfig extends DatabaseConfig(
"com.mysql.cj.jdbc.Driver",
"jdbc:mysql://localhost:3306/mydb")
def getConnection(implicit config: DatabaseConfig): Unit = {
println(config.url)
}
getConnection
(二）隐式类
背景：有一个现有的类，它有一个方法。现在我们需要对这个类的功能进行拓展，额外补充一个方法。但是，不允许直接修改原来的类的代码。
假设这里有一个类User，它的内部有一个方法 insertUser
/**
* 隐式类
*
* 背景：有一个现成的类，它有一个方法。我们现在需要对这个类的功能进行扩展：额外补充一个新方法
*
* 但是：不允许直接修改原来的类的代码
*
* 思路：
* 1.补充一个新的类，把这个新的方法写到这个类中
* 2.补充一个隐式转换函数，把这个旧类转成这个新类
*
* */
object imp05 {
class User {
def insertUser(): Unit = {
println("添加一个新用户......")
}
}
class UserExt {
def updateUser():Unit = {
println("修改用户......")
}
}
implicit def XXX(user: User):UserExt = {
new UserExt
}
def main(args: Array[String]): Unit = {
val u1 = new User()
u1.insertUser()
u1.updateUser()
}
}
这个程序运行起来非常的稳定了，同时又不要去改动它之前的代码。 我们的基本思路是：再写一个类，然后在其中补充一个方法，然后让当前的类去使用这个方法。
/**
* 隐式类
*
* 背景：有一个现成的类，它有一个方法。我们现在需要对这个类的功能进行扩展：额外补充一个新方法
* 但是：不允许直接修改原来的类的代码
*
* 思路：
* 1.补充一个新的类，把这个新的方法写到这个类中
* 2.补充一个隐式转换函数，把这个旧类转成这个新类
*
* 隐式类：
* 1. class 前面加implicit
* 2. 入参就是要扩展功能的那个对象
* */
object imp05 {
class User {
def insertUser(): Unit = {
println("添加一个新用户......")
}
}
implicit class UserExt(user: User) {
def updateUser():Unit = {
println("修改用户......")
}
}
// implicit def XXX(user: User):UserExt = {
// new UserExt
// }
def main(args: Array[String]): Unit = {
val u1 = new User()
u1.insertUser()
u1.updateUser()
}
}
这样通过添加： 一个class + 一个 隐式function 的方式，对代码功能进行了拓展。
还可以更进一步简化: 思路如下：function 是一个函数，而构造函数也是函数，并且函数的名称并不敏感，只需要实现把一种类型，转换为另一种类型，就可以了。
最后：把implicit 加在类的前面，就是隐式类。
