Implict conversion
隐式定义是编译器为了修正类型错误而添加的定义，通过在程序中添加隐式定义，自动进行类型转换
scala.Predef中scala.Int转换为java.lang.Integer的隐式转换
implicit def int2Integer(x: Int) = java.lang.Integer.valueOf(x)
隐式转换规则：
- 标记：必须用
implicit标记
implicit def intToString(x: Int) = x.toString
- 作用域：只使用作用域内部的隐式转换，转换方法作为单一标识符，或者是位于伴生对象中
单一标识符single identifier：假设一个转换方法
convert(x:Int)，不能用someVariable.convert(x)调用，而是可以直接使用convert(x)调用
- 无歧义：只能存在一种隐式转换，不能冲突
- 显式优先：如果类型检查无误，不会尝试进行隐式操作
用途
- 隐式转换为期望类型，例如
Int转Double
implicit def int2double(x: Int): Double = x.toDouble
- 转换方法调用对象的类型
与新的类型交互操作
class Rational(n: Int, d: Int) {
...
def + (that: Rational): Rational = ...
def + (that: Int): Rational = ...
}
scala> val oneHalf = new Rational(1, 2)
oneHalf: Rational = 1/2
scala> implicit def intToRational(x: Int) = new Rational(x, 1)
intToRational: (x: Int)Rational
scala> 1 + oneHalf
res2: Rational = 3/2
- 模拟新的语法
Map(1 -> "one", 2 -> "two", 3 -> "three")中的箭头语法定义，位于Predef.scala中
implicit final class ArrowAssoc[A](private val self: A) extends AnyVal {
@inline def -> [B](y: B): Tuple2[A, B] = Tuple2(self, y)
def →[B](y: B): Tuple2[A, B] = ->(y)
}
- 隐式类
编译器自动生成隐式转换，从隐式类的参数转换为对应的类本身
隐式类不能是一个样本类，它的构造函数只能有一个参数，同时必须位于其他对象，类或特质中
case class Rectangle(width: Int, height: Int)
//定义隐式类
implicit class RectangleMaker(width: Int) {
def x(height: Int) = Rectangle(width, height)
}
// 编译器自动生成一个隐式方法，从构造函数转换为隐式类
implicit def RectangleMaker(width: Int) = new RectangleMaker(width)
//使用
scala> val myRectangle = 3 x 4
myRectangle: Rectangle = Rectangle(3,4)
- 隐式对象
形如implicit object，例如scala.math.Ordering的伴生对象中定义了众多的隐式对象
trait IntOrdering extends Ordering[Int] {
def compare(x: Int, y: Int) = java.lang.Integer.compare(x, y)
}
implicit object Int extends IntOrdering
当需要隐式参数(implict ordering:Ordering[Int])时，编译器传递给它的就是scala.math.Ordering.Int对象
Implicit parameter
方法可以有一个隐式参数列表，在参数列表的开始处由implicit关键字标记，如果隐式参数列表省略，会自动在作用域范围内寻找对应类型的隐式变量
隐式参数最常见的用法是提供显示参数列表的一些类型信息，比如Ordering,ClassTag
def maxListImpParm[T](elements: List[T])
(implicit ordering: Ordering[T]): T =
elements match {
case List() =>
throw new IllegalArgumentException("empty list!")
case List(x) => x
case x :: rest =>
val maxRest = maxListImpParm(rest)(ordering)//ordering可以省略，编译器可以用方法的隐式参数填充
if (ordering.gt(x, maxRest)) x
else maxRest
}
隐式参数的类型最好使用自定义名称的类型，以免冲突，例如不要直接使用隐式类型为(T,T)=>Boolen函数，容易影响到其他的函数
标准库Predef中有如下函数
@inline def implicitly[T](implicit e: T) = e
所以可以在方法体内部不使用隐式参数的名称，通过implicitly[Ordering[T]]获得类型为Ordering[T]的隐式定义
def maxList[T](elements: List[T])
(implicit ordering: Ordering[T]): T =
elements match {
case List() =>
throw new IllegalArgumentException("empty list!")
case List(x) => x
case x :: rest =>
val maxRest = maxList(rest)
if (implicitly[Ordering[T]].gt(x, maxRest)) x
else maxRest
}
视界 Context Bound
进一步省略形参中的参数名
def maxList[T : Ordering](elements: List[T]): T =
elements match {
case List() =>
throw new IllegalArgumentException("empty list!")
case List(x) => x
case x :: rest =>
val maxRest = maxList(rest)
if (implicitly[Ordering[T]].gt(x, maxRest)) x
else maxRest
}
使用视界(context bound)语法[T: Bound]：表明类型参数T，隐含参数Bound[T]
def g[A : B](a: A) = h(a)
//等价于
def g[A](a: A)(implicit ev: B[A]) = h(a) //h需要一个隐式类型为B[A]的隐式值
Scala数组是泛型，会进行类型擦除，为了在运行时获取类型信息，需要ClassTag
scala> def mkArray[T : ClassTag](elems: T*) = Array[T](elems: _*)
mkArray: [T](elems: T*)(implicit evidence$1: scala.reflect.ClassTag[T])Array[T]
scala> mkArray(42, 13)
res0: Array[Int] = Array(42, 13)
scala> mkArray("Japan","Brazil","Germany")
res1: Array[String] = Array(Japan, Brazil, Germany)
//内部实际调用
mkArray[String]("Japan", "Brazil", "Germany")((ClassTag.apply[String](classOf[java.lang.String]): scala.reflect.ClassTag[String]));
scala.reflect.ClassTag通过runtimeClass字段获取运行时类型信息
视界与类型参数的上界含义完全不同，
[T <: Bound[T]]指定T是Bound[T]的子类型
支持形如[K : Ordering : ClassTag]的多个隐式参数的用法，其含义为泛型类型K，隐式参数scala.reflect.ClassTag[K]和Ordering[K]
多个隐式转换的选择
多个隐式转换都可行的时候，优先选择更具体的隐式转换
- 如果前者的参数类型是后者的子类型，选前者，例如字符串优先选
String而不是Any类型的参数 - 位于子类中的方法优先于父类中的方法，例如遇到
"abc".reverse方法时，优先使用的是转换为StringOps的隐式转换
//Predet中的方法
@inline implicit def augmentString(x: String): StringOps = new StringOps(x)
//Predef继承的LowPriorityImplicits类中的隐式转换
implicit def wrapString(s: String): WrappedString = if (s ne null) new WrappedString(s) else null
使用
scalac -Xprint:typer xxx.scala可以查看具体的类型
