这篇短文将结合实例对隐式转换的各种场景进行解释和总结，希望看完的人能够安全驶过隐式转换这个大坑。

隐式转换函数

隐式转换函数有两种作用场景。

• 1 转换为期望类型：就是指一旦编译器看到X，但需要Y，就会检查从X到Y的隐式转换函数。
• 2 转换方法的调用者：简单来说，如obj.f()，如果obj对象没有f方法，则尝试将obj转换为拥有f方法的类型。

object ImpFunction extends App { class Dog(val name: String) { def bark(): Unit = println(s"$name say: Wang !") } implicit def double2int(d: Double): Int = d.toInt implicit def string2Dog(s: String): Dog = new Dog(s) val f: Int = 1.1 //转换为期望类型,1.1通过double2int转成了Int类型 println(f) "Teddy".bark() // 转换方法的调用者,字符串通过string2Dog转成了Dog, 于是有了bark方法}// output// 1// Teddy say: Wang !

val f: Int = 1.1 因为类型不匹配，这段本来是无法通过编译的，但是编译器发现存在一个Double至Int的隐式转换函数，所以进行了隐式转换。

"Teddy".bark() String类型本来是没有bark方法的，但是编译器发现了隐式转换string2Dog可以使得String转成一种拥有bark方法的类型，相当于进行了这样的转换：string2Dog("Teddy").bark()。

注意事项

需要注意的是，编译器只关心隐式转换函数的输入输出类型，不关心函数名，为避免歧义，同一个作用域中不能有输入输出类型相同的两个隐式转换函数，不然编译器会报错。

隐式类

Scala 2.10引入了一种叫做隐式类的新特性。隐式类指的是用implicit关键字修饰的类。使用情况与隐式转换函数类似，可以看做将类的构造函数定义为隐式转换函数，返回类型就是这个类。

package io.github.liam8.implobject ImpClass extends App { implicit class Dog(val name: String) { def bark(): Unit = println(s"$name say: Wang !") } "Teddy".bark()}

注意事项

这段来自官网https://docs.scala-lang.org/zh-cn/overviews/core/implicit-classes.html隐式类有以下限制条件：

• 1 只能在别的trait/类/对象内部定义。

 object Helpers { implicit class RichInt(x: Int) // 正确！ } implicit class RichDouble(x: Double) // 错误！

• 2 构造函数只能携带一个非隐式参数。

 implicit class RichDate(date: java.util.Date) // 正确！ implicit class Indexer[T](collecton: Seq[T], index: Int) // 错误！ implicit class Indexer[T](collecton: Seq[T])(implicit index: Index) // 正确！

虽然我们可以创建带有多个非隐式参数的隐式类，但这些类无法用于隐式转换。

• 3 在同一作用域内，不能有任何方法、成员或对象与隐式类同名。
• 注意：这意味着隐式类不能是case class。

 object Bar implicit class Bar(x: Int) // 错误！ val x = 5 implicit class x(y: Int) // 错误！ implicit case class Baz(x: Int) // 错误！

隐式参数 & 隐式值

package io.github.liam8.implobject ImpParam extends App { def bark(implicit name: String): Unit = println(s"$name say: Wang !") implicit val t: String = "Hot Dog" bark}

参数加上implicit就成了隐式参数，需要与隐式值(变量定义加上implicit)搭配使用，最后一行的bark缺少了一个String类型的参数，编译器找到了String类型的隐式值，便将其传入，相当于执行了bark(t)。

implicit关键字会作用于函数列表中的的所有参数，如def test(implicit x:Int, y: Double)这样定义函数，x和y就都成了隐式函数。但是通常我们只希望部分参数为隐式参数，就好比通常会给部分参数提供默认值而不是全部都指定默认值，于是隐式参数常常与柯里化函数一起使用，这样可以使得只有最后一个参数为隐式参数，例如def test(x: Int)(implicit y: Double)。

是完整的例子。

object ImpParamWithCurry extends App { def bark(name: String)(implicit word: String): Unit = println(s"$name say: $word !") implicit val w: String = "Wang" bark("Hot Dog")}

注意事项

下面这段来自https://blog.csdn.net/m0_37138008/article/details/78120210

• 1)当函数没有柯里化时，implicit关键字会作用于函数列表中的的所有参数。
• 2)隐式参数使用时要么全部不指定，要么全不指定，不能只指定部分。
• 3)同类型的隐式值只能在作用域内出现一次，即不能在同一个作用域中定义多个相同类型的隐式值。
• 4)在指定隐式参数时，implicit 关键字只能出现在参数开头。
• 5)如果想要实现参数的部分隐式参数，只能使用函数的柯里化，
• 如要实现这种形式的函数，def test(x:Int, implicit y: Double)的形式，必须使用柯里化实现：def test(x: Int)(implicit y: Double).
• 6)柯里化的函数， implicit 关键字只能作用于最后一个参数。否则，不合法。
• 7)implicit 关键字在隐式参数中只能出现一次，柯里化的函数也不例外！

隐式对象

类似于隐式值, 要结合隐式参数使用。先看一个栗子(下面的代码需要认真体会)。

package io.github.liam8.implobject ImpObject extends App { //定义一个`排序器`接口，能够比较两个相同类型的值的大小 trait Ordering[T] { //如果xy返回1，x==y则返回0. def compare(x: T, y: T): Int } //实现一个Int类型的排序器 implicit object IntOrdering extends Ordering[Int] { override def compare(x: Int, y: Int): Int = { if (x < y) -1 else if (x == y) 0 else 1 } } //实现一个String类型的排序器 implicit object StringOrdering extends Ordering[String] { override def compare(x: String, y: String): Int = x.compareTo(y) } //一个通用的max函数 def max[T](x: T, y: T)(implicit ord: Ordering[T]): T = { if (ord.compare(x, y) >= 0) x else y } println(max(1, 2)) println(max("a