1、隐式参数和隐式值
函数的形式参数如果用implicit修饰则是隐式参数，隐式参数可以有一个默认值，调用的时候可以不传递参数，但是该调用作用域内部必须有一个类型相同的隐式值或者是默认的或者手动传递一个值否则报错
def sum（x:Int）（implicit init:Int=12（默认））{...}
隐式值 implicit val text =12
2、隐式函数：
函数前面用implicit修饰则是隐式函数。
一、隐式转化的作用：对一个类进行增强。
泛型的分类：
[T <: UpperBound]：上界
[T >: LowerBound]：下届
[T <% ViewBound]：视图界定
[T : ContextBound]：上下文界定。
1、视图界定隐式函数：需要一个隐式函数 [T <% M]关系意味着T可以被隐式转换成M[T]
2、上下文界定需要一个隐式值。[T : M] 要求必须存在一个类型为M[T]的隐式值
packagecom.jerome.fastScala.MyImplicit
//视图界定需要一个隐式函数将T转化为Ordered[T]或者子类
class ViewChoose[T<%Ordered[T]] {
def choose(first:T,second:T):T={
if(first>second)first else second
}
}
//上下文界定必须有一个隐式值
class contextBound[T:Ordering]{
def choose(first:T,second:T):T={
val ord=implicitly[Ordering[T]]
if(ord.compare(first,second)>0) first else second
}
}
object ViewChoose{
def main(args: Array[String]): Unit = {
import com.jerome.fastScala.MyImplicit.MyImplicit._
/*
* 视图界定必须有一个隐式转换的函数
*valvc=new ViewChoose[Girl]
valg1=new Girl("jerome",88)
valg2=new Girl("marry",89)
valres = vc.choose(g1, g2)
print(res.name)*/
val tb=new contextBound[Girl]()
val g1=new Girl("jerome",88)
//这里的Girl只是new一个对象，其内部不存在可以比较的方法，但是通过隐式转化之后转化成ordering或者ordered则可以用于比较了
valg2=new Girl("marry",89)
valres2=tb.choose(g1,g2)
println(res2.name)
}
}
其中MyImplicit._的内容是：
object MyImplicit{
implicit val a="marry"
implicit val b=12
/*隐式函数用于视图界定
implicit def Girl2OrderedGirl(girl:Girl)=new Ordered[Girl]{
overridedefcompare(that:Girl):Int={
girl.faceValue-that.faceValue
}
}*/
//隐式值用于上下文界定
implicit val girl2Ordering=new Ordering[Girl]{
overridedefcompare(x:Girl,y:Girl):Int={
x.faceValue-y.faceValue
}
}
}
视图界定和上下文界定隐式转化方法二
案列看代码：
packagecom.jerome.fastScala.MyImplicitNew
class MISSLeft[T] {
//视图界定
def choose(first:T,second:T)(implicit ord:T=>Ordered[T]):T={
if(first>second)first else second
}
//上下文界定
def select(first:T,second:T)(implicit ord:Ordering[T]):T={
if(ord.compare(first,second)>0)first else second
}
//如何相互转化，传入一个上下文的隐士值，然后在函数内部将这个隐式值利用隐式函数转化为可以直接用于比较的ordered
T-->Ordering[T]--->ordered[T]
def random(first:T,second:T)(implicitord:Ordering[T]):T={
import ordered._
if(first>second)first else second
}
}
object Test implicit{
def main(args: Array[String]): Unit = {
val ml=new MISSLeft[Girl]
val g1=new Girl("jerome",54,57)
val g2=new Girl("marry",56,47)
import com.jerome.fastScala.MyImplicitNew.MyPreDef._
val res1=ml.select(g1,g2)
va lres2=ml.choose(g1,g2)
val res3=ml.random(g1,g2)
println(res3.name)
}
}
其中 importcom.jerome.fastScala.MyImplicitNew.MyPreDef._的隐式函数和隐式值为：
object MyPreDef {
//隐式函数
implicit def girl2Ordered=(girl:Girl)=>newOrdered[Girl]{
overridedefcompare(that:Girl):Int={
if(girl.faceValue==that.faceValue){
girl.size - that.size
}else{
girl.faceValue-that.faceValue
}
}
}
隐式值
也可以写成
implicit val girlOrdering =new Ordering[Girl]{。。。}
implicit object girlOrdering extendsOrdering[Girl]{
override def compare(x:Girl,y:Girl):Int={
if(x.faceValue==y.faceValue){
x.size-y.size
}else{
x.faceValue-y.faceValue
}
}
}
}
其中：import ordered._ 中的ordering-->ordered
object ordered {
implicit def ordering2ordered[T](x:T)(implicitord:Ordering[T]):Ordered[T]={
newOrdered[T]{
overridedefcompare(that:T):Int={
ord.compare(x,that)
}
}
}
}
