scala隐式转换总结
2017-08-30 17:00
253 查看
转载地址:https://my.oschina.net/aiguozhe/blog/35968
Scala提供的隐式转换特性可以在效果上给一个类增加一些方法,或者用于接收不同类型的对象.
然而使用Scala的隐式转换是有一定的限制的,总结如下:
implicit关键字只能用来修饰方法、变量(参数)和伴随对象。
隐式转换的方法(变量和伴随对象)在当前范围内才有效。如果隐式转换不在当前范围内定义(比如定义在另一个类中或包含在某个对象中),那么必须通过import语句将其导。举例
但有一种情况例外,源类型或目标类型(包括源类型和目标类型的类型变量的类型)的伴随对象中隐式转换函数(或变量,伴随对象)不需要显示导入。 比如
这样规定的好处是,通过限制隐式转换的有效范围,使维护和理解代码变得相对容易.
一般来说,scala编译器会首先在方法调用处的当前范围内查找隐式转换函数;如果没有找到,会尝试在源类型或目标类型(包括源类型和目标类型的类型变量的类型)的伴随对象中查找转换函数,如果还是没找到,则拒绝编译。
比如:
运行上述代码,先调用 D2C转换函数将new D()转换成C类, 然后调用C类的printC方法;但发现传入的参数类型是B类,于是搜索当前范围有无合适的转换函数,发现B2C转换函数符合要求。
又比如:
运行上述代码,先调用 D2C转换函数将new D()转换成C类, 然后调用C类的printC方法, 但发现传入的参数类型是A类。由于当前范围无合适的转换函数,故搜索object A和object C内有无合适的转换函数,最后发现object A内有合适的转换函数。
如果同时在object A和object C内发现合适的转换函数,有可能导致编译错误。
再比如:
运行上述代码,printM需要传入类型为M[C]的参数,由于传入了类型为M[A],又在当前范围内没有合适转换函数, 因此同时在object M,object A和object C内搜索合适的转换函数,如果发现两个或以上合适的转换函数,那么有可能导致编译错误。
源类型和目标类型最多只发生一次隐式转换。举例
执行printC(new A)时会报类型不匹配的错
注意:这里所说的”最多只发生一次隐式转换“的意思是,源类型最多只经过一次函数转换变成目标类型(或与目标类型兼容的类型),但在一次方法调用中,可能发生多次源类型和目标类型之间的转换。
比如
另外,当函数定义了隐式参数时,也可能发生多次隐式转换:
运行上述代码,首先调用user2PrintOps函数将"a"转换成PrintOps, 然后调用print方法。由于调用print时没有显式提供implicit参数,因此尝试在当前范围内搜索合适的implicit转换值。编译器发现str2int这个隐式转换函数能提供print所需int类型,但str2int又需要一个隐式的String和一个隐式的List[Int]。编译器继续在当前范围内搜索,最后发现getString和newList这两个隐式转换函数能分别提供一个String实例和一个List[Int]实例。至此编译器知道要先调用getString和newList,再调用str2int,最后调用print。
如果当前的类型匹配或类型兼容,则不会进行隐式转换。举例:
如果当前范围内有两个或以上合适的隐式转换函数,Scala会怎么处理呢?
在Scala 2.7以及之前的版本中,编译器会发出错误。这跟重载的情况是一样的。比如有两个重载方法foo,一个接收String参数,另一个接收AnyRef参数,当foo(null) 这样写的时候,编译器会拒绝编译。但在Scala 2.8中,编译器会选择foo(String)这个重载方法,即编译器会选择一个更具体的方法。同样当碰到两个或两个以上合适的隐式转换函数时,编译器也会选择一个更具体的方法。至于哪个方法被认为更具体,可以根据以下的规则进行判断:
a) 前者的函数参数类型是后者的子类型,则前者更具体
b) 假设两个隐式转换函数都定义在一个类中,如果前者所在的类是后者的子类,那么前者更具体
总结:如果有多个隐式转换函数符合转换要求,scala最新版会选择执行参数类型是子类型或者方法定义在子类中的方法来匹配。
由于隐式转换会给代码带来“魔幻”效果,对于不熟悉这种特性的人会感觉难受。 笔者曾经发现一个利用隐式转换改变方法执行顺序的例子:
笔者觉得,如没必要尽量少用隐式转换,毕竟太“魔幻”的代码理解起来还是要费点劲。
BTW:
命名函数的参数可以声明为implicit,但implicit必须出现在首位,并且是对所有的参数有效,不能只给某些参数声明为implicit,比如:
Scala提供的隐式转换特性可以在效果上给一个类增加一些方法,或者用于接收不同类型的对象.
然而使用Scala的隐式转换是有一定的限制的,总结如下:
implicit关键字只能用来修饰方法、变量(参数)和伴随对象。
隐式转换的方法(变量和伴随对象)在当前范围内才有效。如果隐式转换不在当前范围内定义(比如定义在另一个类中或包含在某个对象中),那么必须通过import语句将其导。举例
package demo { package util { import java.util.Date import java.text.SimpleDateFormat object DateUtil { class DateWrapper(date: Date) { def format(str: String) = new SimpleDateFormat(str).format(date) } implicit def toDateWrapper(date: Date) = new DateWrapper(date) } } package service { import java.text.SimpleDateFormat import java.util.Date // 注: 必须将object Rest的定义放在class Rest之前,或者显式指出str2Date的返回类型,否则编译不通过 object Rest{ class RichDate(str: String){ def toDate(): Date = new SimpleDateFormat("yyyy-MM-dd").parse(str) } implicit def str2Date(str: String) = new RichDate(str) } class Rest { import util.DateUtil._ import Rest._ // 必须把demo.util包下的伴随对象DateWrapper中的所有成员引进来 def today = new Date().format("yyyy-MM-dd"); // 伴随对象 Rest中定义了一个隐式转换函数 def getDate(str: String): Date = str.toDate(); } } object SC4 { import demo.service.Rest def main(args: Array[String]) ={ println (new Rest().today) println(new Rest().getDate("2011-01-09")) } } }
但有一种情况例外,源类型或目标类型(包括源类型和目标类型的类型变量的类型)的伴随对象中隐式转换函数(或变量,伴随对象)不需要显示导入。 比如
package demo{ object MyTestApp{ def main(args: Array[String]): Unit = { val myTest = new MyTest(); myTest.printInt(4) myTest.printYourTest(myTest) // the source type is of MyTest while the target require YourTest myTest.fuxkTest() // there is no method on MyTest but we can still call it } } class YourTest{ override def toString = "Your Test" def fuxkTest() = print("fuxk Test"); } object YourTest{ implicit def myTest2YourTest = new YourTest } class MyTest{ import MyTest._ def printStr(str: String) = println(str) // you can't do it like `printStr(i)` unless you bring the implicit converter `MyTest.int2String`into scope def printInt(i: Int) = printStr(i) def printYourTest(obj: YourTest) = println(obj) def getYorTest(): YourTest = this; } object MyTest { implicit def int2String(i: Int ): String = i.toString implicit def myTest2YourTest(obj: MyTest): YourTest= new YourTest // implicit val myTest2YourTest = (obj : MyTest) => new YourTest } }
这样规定的好处是,通过限制隐式转换的有效范围,使维护和理解代码变得相对容易.
一般来说,scala编译器会首先在方法调用处的当前范围内查找隐式转换函数;如果没有找到,会尝试在源类型或目标类型(包括源类型和目标类型的类型变量的类型)的伴随对象中查找转换函数,如果还是没找到,则拒绝编译。
比如:
object ABCDMain extends App { class B class C { override def toString() = "I am C"; def printC(c: C) = println(c); } class D implicit def B2C(b: B) = { println("B2C") new C } implicit def D2C(d: D) = { println("D2C") new C } new D().printC(new B) }
运行上述代码,先调用 D2C转换函数将new D()转换成C类, 然后调用C类的printC方法;但发现传入的参数类型是B类,于是搜索当前范围有无合适的转换函数,发现B2C转换函数符合要求。
又比如:
object ABCDMain extends App { class A object A { // implicit def A2C(a: A) = { // println("A.A2C"); // new C // } } class C { override def toString() = "I am C"; def printC(c: C) = println(c); } object C { implicit def A2C(a: A) = { println("C.A2C"); new C } } class D implicit def D2C(d: D) = { println("D2C") new C } new D().printC(new A) }
运行上述代码,先调用 D2C转换函数将new D()转换成C类, 然后调用C类的printC方法, 但发现传入的参数类型是A类。由于当前范围无合适的转换函数,故搜索object A和object C内有无合适的转换函数,最后发现object A内有合适的转换函数。
如果同时在object A和object C内发现合适的转换函数,有可能导致编译错误。
再比如:
object ABCDMain extends App { class A object A{ //implicit def MA2MC(ma: M[A]) ={ // new M[C]; //} } class C object C{ implicit def MA2MC(ma: AnyRef) = { new M[C]; } } class D { def printM(m: M[C]) = println("i am M[C]"); } class M[T] object M { implicit def MA2MC(ma: M[A]) = { new M[C]; } } new D().printM(new M[A]) }
运行上述代码,printM需要传入类型为M[C]的参数,由于传入了类型为M[A],又在当前范围内没有合适转换函数, 因此同时在object M,object A和object C内搜索合适的转换函数,如果发现两个或以上合适的转换函数,那么有可能导致编译错误。
源类型和目标类型最多只发生一次隐式转换。举例
class A{ override def toString() = "I am A"; } class B{ override def toString() = "I am B"; } class C{ override def toString() = "I am C"; } implicit def A2B(a: A) = new B implicit def B2C(b: B) = new C def printC(c: C) = println(c); printC(new B); // 会调用B2C函数进行隐式转换 printC(new A); // 对 new A 不能连续做两次隐式转换
执行printC(new A)时会报类型不匹配的错
注意:这里所说的”最多只发生一次隐式转换“的意思是,源类型最多只经过一次函数转换变成目标类型(或与目标类型兼容的类型),但在一次方法调用中,可能发生多次源类型和目标类型之间的转换。
比如
class C { override def toString() = "I am C"; def printC(c: C) = println(c); } class D implicit def B2C (b: B) = { println("B2C"); new C } implicit def D2C(d: D) = { println("D2C"); new C } new D().printC(new B); // 这里会发生两次隐式转换, 一次是D2C, 一次是B2C
另外,当函数定义了隐式参数时,也可能发生多次隐式转换:
object Main extends App { class PrintOps() { def print(implicit i: Int) = println(i); } implicit def user2PrintOps(s: String) = { println("use2PrintOps") new PrintOps } implicit def str2int(implicit s: String, implicit l: List[Int]): Int = { println("str2int") Integer.parseInt(s) } implicit def getString = { println("getString") "123" } implicit def newList = { println("newList") List(2) } "a".print }
运行上述代码,首先调用user2PrintOps函数将"a"转换成PrintOps, 然后调用print方法。由于调用print时没有显式提供implicit参数,因此尝试在当前范围内搜索合适的implicit转换值。编译器发现str2int这个隐式转换函数能提供print所需int类型,但str2int又需要一个隐式的String和一个隐式的List[Int]。编译器继续在当前范围内搜索,最后发现getString和newList这两个隐式转换函数能分别提供一个String实例和一个List[Int]实例。至此编译器知道要先调用getString和newList,再调用str2int,最后调用print。
如果当前的类型匹配或类型兼容,则不会进行隐式转换。举例:
class AA extends A{ override def toString() = "I am AA which inherits from A" } implicit def AA2A(aa: AA) = { println("AA --> A"); new A } def printA(a: A) = println(a); printA(new AA) // 因为AA是A的子类型,所以可以把AA类型的值传递给A类型的变量
如果当前范围内有两个或以上合适的隐式转换函数,Scala会怎么处理呢?
在Scala 2.7以及之前的版本中,编译器会发出错误。这跟重载的情况是一样的。比如有两个重载方法foo,一个接收String参数,另一个接收AnyRef参数,当foo(null) 这样写的时候,编译器会拒绝编译。但在Scala 2.8中,编译器会选择foo(String)这个重载方法,即编译器会选择一个更具体的方法。同样当碰到两个或两个以上合适的隐式转换函数时,编译器也会选择一个更具体的方法。至于哪个方法被认为更具体,可以根据以下的规则进行判断:
a) 前者的函数参数类型是后者的子类型,则前者更具体
b) 假设两个隐式转换函数都定义在一个类中,如果前者所在的类是后者的子类,那么前者更具体
总结:如果有多个隐式转换函数符合转换要求,scala最新版会选择执行参数类型是子类型或者方法定义在子类中的方法来匹配。
由于隐式转换会给代码带来“魔幻”效果,对于不熟悉这种特性的人会感觉难受。 笔者曾经发现一个利用隐式转换改变方法执行顺序的例子:
// TernaryOp对象提供了类似java的三目运算符号操作 object TernaryOp { class Ternary[T](t: T) { println("Ternary") def is[R](bte: BranchThenElse[T,R]) = { println("is ... ") if (bte.branch(t)) bte.then(t) else bte.elze(t) } } class Branch[T](branch: T => Boolean) { println("branch"); def ?[R] (then: T => R) = new BranchThen(branch,then) } class BranchThen[T,R](val branch: T => Boolean, val then: T => R){ println("BranchThen") } class Elze[T,R](elze: T => R) { println("Elze") def :: (bt: BranchThen[T,R]) = new BranchThenElse(bt.branch,bt.then,elze) } class BranchThenElse[T,R](val branch: T => Boolean, val then: T => R, val elze: T => R) implicit def any2Ternary[T](t: T) = new Ternary(t) implicit def fct2Branch[T](branch: T => Boolean) = new Branch(branch) implicit def fct2Elze[T,R](elze: T => R) = new Elze(elze) def test = { this.getClass.getSimpleName is {s: String => s.endsWith("$")} ? {s: String => s.init} :: {s: String => s} } } TernaryOp.test // 思考一下test中会发生怎样转换?若搞不明白,请参考https://gist.github.com/1388106
笔者觉得,如没必要尽量少用隐式转换,毕竟太“魔幻”的代码理解起来还是要费点劲。
BTW:
命名函数的参数可以声明为implicit,但implicit必须出现在首位,并且是对所有的参数有效,不能只给某些参数声明为implicit,比如:
def maxFunc(implicit i1: Int, i2: Int) = i1 + i2
相关文章推荐
- scala中隐式转换之总结
- 对Scala隐式转换的总结
- scala总结(4) -- 隐式转换以及隐式参数
- scala的隐式转换学习总结(详细)
- Scala多维数组、Java数组与Scala数组的隐式转换
- 第63讲Scala中隐式参数与隐式转换的联合使用解析
- 第66讲scala 中伴生对象的隐式转换
- scala中的隐式转换详解
- Scala隐式转换之隐式参数(1)
- 深入理解Scala中的隐式转换系统
- 记录: 一次解决整型溢出攻击(使用scala,隐式转换)
- Scala中的隐式转换、隐式参数、隐式类
- 关于Scala的implicit(隐式转换)的思考
- scala的implicit关键字----不仅仅是隐式类型转换
- Scala学习教程笔记三之函数式编程、集合操作、模式匹配、类型参数、隐式转换、Actor、
- Scala深入浅出进阶经典 第61讲:Scala中隐式参数与隐式转换的联合使用实战详解及其在Spark中的应用源码解析
- Scala 隐式转换案例(二)
- JavaScript中的一些隐式转换和总结(推荐)
- 扒一扒scala隐式转换
- scala隐式转换&尾递归