scala> def person(implicit name : String) = name   //name为隐式参数
person: (implicit name: String)String

直接调用person方法

scala> person
<console>:9: error: could not find implicit value for parameter name: Stringperson^

报错！编译器说无法为参数name找到一个隐式值

scala> implicit val p = "mobin"   //p被称为隐式值
p: String = mobin
scala> person
res1: String = mobin

因为将p变量标记为implicit，所以编译器会在方法省略隐式参数的情况下去搜索作用域内的隐式值作为缺少参数。

scala> implicit val p1 = "mobin1"
p1: String = mobin1
scala> person
<console>:11: error: ambiguous implicit values:both value p of type => Stringand value p1 of type => Stringmatch expected type Stringperson^

匹配失败，所以隐式转换必须满足无歧义规则，在声明隐式参数的类型是最好使用特别的或自定义的数据类型，不要使用Int,String这些常用类型，避免碰巧匹配

scala> def foo(msg : String) = println(msg)
foo: (msg: String)Unitscala> foo(10)
<console>:11: error: type mismatch;
found : Int(10)
required: String
foo(10)
^

显然不能转换成功，解决办法就是定义一个转换函数给编译器将int自动转换成String

scala> implicit def intToString(x : Int) = x.toString
intToString: (x: Int)Stringscala> foo(10)
10

隐式转换调用类中本不存在的方法

例3：通过隐式转换，使对象能调用类中本不存在的方法

class SwingType{def  wantLearned(sw : String) = println("兔子已经学会了"+sw)
}
object swimming{implicit def learningType(s : AminalType) = new SwingType
}
class AminalType
object AminalType extends  App{import com.mobin.scala.Scalaimplicit.swimming._val rabbit = new AminalTyperabbit.wantLearned("breaststroke")         //蛙泳
}

编译器在rabbit对象调用时发现对象上并没有wantLearning方法，此时编译器就会在作用域范围内查找能使其编译通过的隐式视图，找到learningType方法后，编译器通过隐式转换将对象转换成具有这个方法的对象，之后调用wantLearning方法

可以将隐式转换函数定义在伴生对象中，在使用时导入隐式视图到作用域中即可（如例4的learningType函数）

还可以将隐式转换函数定义在凶对象中，同样在使用时导入作用域即可，如例4

例4：

class SwingType{def  wantLearned(sw : String) = println("兔子已经学会了"+sw)
}package swimmingPage{
object swimming{implicit def learningType(s : AminalType) = new SwingType  //将转换函数定义在包中
  }
}
class AminalType
object AminalType extends  App{import com.mobin.scala.Scalaimplicit.swimmingPage.swimming._  //使用时显示的导入val rabbit = new AminalTyperabbit.wantLearned("breaststroke")         //蛙泳
}

像intToString，learningType这类的方法就是隐式视图，通常为Int => String的视图，定义的格式如下：

     implicit def  originalToTarget (<argument> : OriginalType) : TargetType

其通常用在于以两种场合中：

1.其所带的构造参数有且只能有一个

2.隐式类必须被定义在类，伴生对象和包对象里

3.隐式类不能是case class（case class在定义会自动生成伴生对象与2矛盾）

4.作用域内不能有与之相同名称的标示符

object Stringutils {implicit class StringImprovement(val s : String){   //隐式类def increment = s.map(x => (x +1).toChar)}
}
object  Main extends  App{import com.mobin.scala.implicitPackage.Stringutils._println("mobin".increment)
}

编译器在mobin对象调用increment时发现对象上并没有increment方法，此时编译器就会在作用域范围内搜索隐式实体，发现有符合的隐式类可以用来转换成带有increment方法的StringImprovement类，最终调用increment方法。

隐式解析机制

即编译器是如何查找到缺失信息的，解析具有以下两种规则：

1.首先会在当前代码作用域下查找隐式实体（隐式方法  隐式类 隐式对象）

2.如果第一条规则查找隐式实体失败，会继续在隐式参数的类型的作用域里查找

类型的作用域是指与该类型相关联的全部伴生模块，一个隐式实体的类型T它的查找范围如下：

（1）如果T被定义为T with A with B with C,那么A,B,C都是T的部分，在T的隐式解析过程中，它们的伴生对象都会被搜索

（2）如果T是参数化类型，那么类型参数和与类型参数相关联的部分都算作T的部分，比如List[String]的隐式搜索会搜索List的

伴生对象和String的伴生对象

（3） 如果T是一个单例类型p.T，即T是属于某个p对象内，那么这个p对象也会被搜索

（4） 如果T是个类型注入S#T，那么S和T都会被搜索