Scala中的隐式转换

1 隐式转换

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

    //隐式转换
    //int i = (int)5.5

    //val i:Int = 5.5。toInt
    implicit def transInt(x:Double):Int={
      x.toInt
    }

//    implicit def trans2(a:Double):Int{
//      a.toInt
//    }

    val i:Int = 5.5

    println(i)

• Scala 进行编译时，会自动识别后将程序进行转换，开发人员无需进行操作。
• 需要保证在当前环境下，只有一个隐式函数能被识别
  

2 利用隐式转换丰富类库功能

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

class MySQL007{
  def insert(id : Int)={
    println("Insert Data id = " + id)
  }
}

class Oracle007{
  def delete(id : Int)={
    println("Delete Data id = " + id)
  }
}



    implicit def transOracle007(x:MySQL007):Oracle007={
      new Oracle007
    }
    val db = new MySQL007
    db.insert(10)

    db.delete(10)

5
Insert Data id = 10
Delete Data id = 10

3 隐式值

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

    //隐式参数
    implicit val n = "Nick"
    def person(implicit name: String) = name
    println(person)

Nick

• 但是如果此时你又相同作用域中定义一个隐式变量，再次调用方法时就会报错：出现二义性
• 不是变量名，是数据类型不能有重复的

    //隐式参数
    implicit val n1 = "Nick"
    implicit val n2 = "Sam"
    def person(implicit name: String) = name
    println(person)

4 隐式类

• 在 scala2.10 后提供了隐式类，可以使用 implicit 声明类，但是需要注意以下几点：

1. 其所带的构造参数有且只能有一个
2. 隐式类必须被定义在“类”或“伴生对象”或“包对象”里
3. 隐式类不能是 case class（case class 在后续介绍）
4. 作用域内不能有与之相同名称的标示符

    //隐式类
    //下面这个构造器的参数要是处理的对象的类型
    implicit class StringImprovement(val s : String){ //隐式类
      def myconcat(separ:String):String = {
        s +separ+ " Scala"
      }
      //重载
      def myconcat():String = {
        s + " Scala"
      }
    }
    println("hello".myconcat("$"))
    println("java".myconcat())
  }

hello$ Scala
java Scala

5 隐式的转换时机

1. 当方法中的参数的类型与目标类型不一致时
2. 当对象调用所在类中不存在的方法或成员时，编译器会自动将对象进行隐式转换

6 隐式解析机制

即编译器是如何查找到缺失信息的，解析具有以下两种规则：

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 都会被搜索。

7 隐式转换的前提

1. 不能存在二义性
2. 隐式操作不能嵌套