比较基础的几条规则:

一、隐式定义的位置:

1、隐式转换可以直接定义在目标文件中

2、隐式转换可以集中定义在某个包中,使用的时候引入包即可(常用

二、什么时候发生隐式转换?

1、方法中的参数类型和实际类型不一致


        implicit def double2Int(x:Double)=x.toInt
        var x:Int=3.5

2、调用的类中不存在方法或者成员的时候

三、什么时候不会发生隐式转换?

1、编译器可以不在隐式转换的时候通过编译,例如  2.0*5

2、转换如果存在二义性,则不会发生隐式转换 A->B | A->C

3、不能进行嵌套的隐式转换。A->B->C【该观点么有任何问题】


更新时间:2016-09-19  10:13:08

补充说明【错误观点,删除线观点错误,个人理解有误】

请关注第三条第三点内容(进行内容的纠正):

不会进行嵌套的隐式转换的说法是不准确的,准确的说是源类型到目标类型的转换只会进行一次 ,我的理解是A->B->C 这个转换实际上只要是到了C就不会继续进行转换,比如A->B->C->D->C的转换是不会发生的。

但是所谓的只进行一次,不是说只能由 A->C , 而不能是 A->B->C , 我不知道我理解的这一点是否正确,因为很多文章实际上并没有把这个问题具体的讲清楚。虽然 A->B->C->D 这种转换看起来比较傻或者是不太可能会发生,但是如果存在特殊的情况,则是可能会出现问题的。

能够进行多次隐式转换的条件也存在,详细推荐查看博客内容:爱国者的OSC博客  这篇文章对隐式转换有比较好的总结和例子。

这里拿出一个例子进行讲解(该例子只是说明可以发生多次转换,但是例子不具备说服力[后面才发现]):
下面例子我在 http://blog.csdn.net/lovehuangjiaju/article/details/47323861 看到的


        package main.scala.ImplicitTest

/**
  * Created by postbird on 2016/9/19.
  */
class A{
    override def toString()={
        "a"
    }
}
class B{
    override def toString()={
        "b"
    }
}
//只有C有printC方法
class C{
    override def toString()={
        "c"
    }
    def printC(c:C)=println(c.toString())
}
class D{
    println("D")
}

object implicitTest {
    def main(args: Array[String]) {
        //创建隐式转换  B->C  我这里指定了C的返回类型
        implicit def B2C(b:B): C ={
            println("B->C")
            new C
        }
        implicit def D2C(d:D):C={
            println("D->C")
            new C
        }
        new D().printC(new B())
        //请注意这个语句
        //首先 D 里面是没有printC()这个函数的,因此会进行隐式转换,也就是
        // D->C
        // 而printC 函数的参数传入的是B 因此又会发生一次隐式转换(B2C)
        // B->C
        //最后才实现了方法的调用
        // 这个例子里面 是经过了两次不同的隐式转换才实现了功能,但是两次隐式转换的原因是因为两个地方需要
        // 因此并不具备代表性

        //输出的结果
//        D
//        D->C
//        B->C
//        c
    }

}


证明不能进行嵌套转换的例子


package main.scala.ImplicitTest

/**
  * Created by postbird on 2016/9/19.
  */

class AA{

}
class BB{

}
class CC{
    def printC(): Unit ={
        println("ccc")
    }
}
object implicitTest3 {
    def main(args: Array[String]):Unit= {
        implicit def A2C(a:AA):BB={
            println("A->B")
            new BB
        }
        implicit def B2C(b:BB):CC={
            println("B->C")
            new CC
        }
        new AA().printC()
        //上述代码报如下错误
        // 可以看出 实际上是不能进行嵌套的转换的
        
//        Error:(28, 18) value printC is not a member of main.scala.ImplicitTest.AA
//        new AA().printC()
//        ^
    }
}


更新时间 2016-09-19  10:41:52

关于要不要使用隐式转换:【别人总结 - -】

 1 即使你能轻松驾驭scala语言中的隐式转换,能不用隐式转换就尽量不用 
 2 如果一定要用,在涉及多次隐式转换时,必须要说服自己这样做的合理性 
 3 如果只是炫耀自己的scala语言能力,请大胆使用