Scala 优雅入门 (六) 隐式转化

隐式函数

自动类型转化

隐式转换函数是以 implicit 关键字声明的带有单个参数的函数。这种函数将会自动应用，将值从一种类型转换为另一种类型, 隐式函数可以优雅的解决数据类型转换,  示例:

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
println(n1 + " " + n2 + " " + n3)

1. 隐式转换函数的函数名可以是任意的，隐式转换与函数名称无关，只与函数签名（函数参数类型和返回值类型）有关。
2. 隐式函数可以有多个(即：隐式函数列表)，但是需要保证在当前环境下，只有一个隐式函数能被识别

 

 

自动丰富类功能

如果需要为一个类增加一个方法，可以通过隐式转换来实现。（动态增加功能）比如想为 MySQL 类增加一个 delete 方法

在实际项目中，如果想要增加新的功能就会需要改变源代码，违背了软件开发的OCP开发原则 (开闭原则 open close priceple), 这种情况下，可以通过隐式转换函数给类动态添加功能。

object ImplicitDemo {

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

 

隐式值

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

object ImplicitValDemo {
  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)
  }
}

 

隐式类

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

1. 其所带的构造参数有且只能有一个
2. 隐式类必须被定义在“类”或“伴生对象”或“包对象”里，即隐式类不能是 顶级的(top-level  objects)
3. 隐式类不能是 case class（样例类）
4. 作用域内不能有与之相同名称的标识符

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

作用与隐式函数丰富类功能相同, 但是更加方便, 相当于把隐式函数和普通类合并为一个隐式类

 

原理

隐式转换时机

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

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

 

 

隐式解析机制

编译器是如何查找到缺失信息的

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

• 如果T被定义为 T with A with B with C,那么A,B,C 都是 T 的部分，在T的隐式解析过程中，它们的伴生对象都会被搜索。
• 如果T是参数化类型，那么类型参数和与类型参数相关联的部分都算作T的部分，比如 List[String] 的隐式搜索会搜索List的伴生对象和 String 的伴生对象。
• 如果T是一个单例类型 p.T，即T是属于某个 p 对象内，那么这个 p 对象也会被搜索。
• 如果T是个类型注入 S#T，那么 S 和 T 都会被搜索

 

 

转换前提

不能存在二义性

隐式操作不能嵌套使用