隐式转换的规则：

1.无歧义规则：隐式转换唯有不存在其他可插入转换的前提下才能插入

 　　若编译器有两种方法修正x+y 如convert1(x)+y,convert2(x)+y，会报错

2.单一调用规则：只尝试一个隐式操作，编译器不会把x+y重写成convert1(convert2(x))+y

3.显式调用规则：若编写的代码没有错误，则不会尝试任何隐式操作

4.命名隐式转换：隐式转换可以任意命名

def main(args:Array[String]):Unit={    implicit def doubleToInt(x:Double)  = x.toInt        val i:Int = 3.5;    println(i)            //编译器在语境中看到了Double，但它需要的是Int。    //如果没有第一行 implicit def doubleToInt(x:Double)  = x.toInt 编译器会报错    //###但是在放弃之前，它搜索了从Double 到Int的隐式转换。    //在本例中，它发现了一个doubleToInt,编译器于是自动插入了doubleToInt调用    //代码实际变成了val i:Int = doubleToInt(3.5)  }

 

 

隐式参数

 

class PreferredPrompt(val preference:String)class PreferredDrink(val preference:String)object Greeter{  def greet(name: String)(implicit prompt:PreferredPrompt,drink:PreferredDrink){ //参数列表被标记为implicit，也就是说它可以被隐式提供    println("Welcome," + name + ". The system is ready.");    println("喝点什么？")    println(drink.preference );    println(prompt.preference);      }}

object Test3{  def main(args:Array[String]):Unit={        //为了让编译器隐式提供参数，必须先定义期望类型的变量    implicit val p1 = new PreferredPrompt("Lin>")    implicit val p2 = new PreferredDrink("tea")    //p1本身也被标记为implicit 否则不能用来补充下面确实的参数列表    Greeter.greet("JJ")  }  /*//不使用隐式参数的情况  def main(args:Array[String]):Unit={    val p1 = new PreferredPrompt("Lin")        Greeter.greet("JJ")(p1)  }  */}

　结果：

Welcome,JJ. The system is ready.喝点什么？teaLin>

 

隐式转换

隐式的函数参数也可以被用作隐式转换。为了明白它的重要性，首先考虑如下泛型函数：

def smaller[T](a:T,b:T)={  if(a

这实际上行不通，因为它并不知道a和b数以一个带有<操作符的类型。

我们可以提供一个转换函数来达到目的：

def smaller[T](a:T,b:T)(implicit order: T=>Ordered(T))={  if(order(a)

由于Ordered[T]特质有一个接受T作为参数的<操作符，因此这个版本是正确的。

注意order是一个带有单个参数的函数，被打上了implicit标签，并且有一个以单个标识符出现的名称。

因此，它不仅是隐式参数，而且是隐式转换。因此，在函数体中可以略去对order的显示调用

def smaller[T](a:T,b:T)(implicit order: T=>ordered(T))={  if(a

 

另一个例子。

object Test4{  def main(args:Array[String]):Unit={    val l1 = List(24,6,7,34,5,14,23)    println(maxListUpBound(l1))  }  def maxListUpBound[T](elements:List[T])(implicit orderer:T=>Ordered[T]):T={//这里用到了隐式转换   //  def maxListPoorStyle[T](elements:List[T])(implicit orderer:(T,T)=>Boolean):T={　　//太过平凡//  def maxListUpBound[T<:Ordered[T]](elements:List[T]):T={　　//不可行，因为T未必是Ordered[T]的子类//  def maxListUpBound(elements:List[Int]):Int={    elements match{      case List()=> throw new IllegalArgumentException("empty list!")      case List(x)=>x      case x::rest =>        val maxRest = maxListUpBound(rest)(orderer)        if(orderer(x) > maxRest) x;         else maxRest    }  }}/*隐式参数的样式规则。最好对隐式参数的类型使用自定义命名的类型，例如不用String 而用  PreferredPrompt 和PreferredDrink 反例def maxListPoorStyle[T](elements:List[T])(implicit orderer:(T,T)=>Boolean):T为了使用函数的这个版本，调用这必须提供类型为(T,T)=>Boolean的orderer参数这种类型过于平凡，包含了任何两个T对象产生的Boolean函数 */

　

视界

def maxListUpBound[T<%Ordered[T]](elements:List[T]):T={  elements match{      case List()=> throw new IllegalArgumentException("empty list!")      case List(x)=>x      case x::rest =>        val maxRest = maxListUpBound(rest)        if(x > maxRest) x;         else maxRest    } }

可以认为 T<%Ordered[T] 是在说， 任何的T都好，只要能把T当做Orderer[T]即可例如 尽管Int不是Ordered[Int]的子类型，但是只要Int到Ordered[Int]的隐式转换可用仍然可以把List[T]传给maxListUpBound