Scala隐式转换和隐式参数详解_Java教程

Scala隐式转换和隐式参数

隐式转换

隐式转换是指在Scala编译器进行类型匹配时，如果找不到合适的类型，那么隐式转换会让编译器在作用范围内自动推导出来合适的类型。
隐式转换的作用是可以对类的方法进行增强，丰富现有类库的功能，或者让不同类型之间可以相互转换。
隐式转换的定义是使用关键字implicit修饰的函数，函数的参数类型和返回类型决定了转换的方向。

例如，下面定义了一个隐式转换函数，可以把Int类型转换成String类型：

				?

									// 定义隐式转换函数

									implicit def intToString(x: Int): String = x.toString

这样，在需要String类型的地方，就可以直接传入一个Int类型的值，编译器会自动调用隐式转换函数进行转换：

				?

									// 使用隐式转换

									val s: String = 123 // 相当于 val s: String = intToString(123)

									println(s.length) // 输出 3

注意，隐式转换函数只与函数的参数类型和返回类型有关，与函数名称无关，所以作用域内不能有相同的参数类型和返回类型的不同名称隐式转换函数。

另外，如果在定义隐式转换函数时使用了柯里化函数形式，那么可以实现多个参数的隐式转换：

				?

									// 定义柯里化形式的隐式转换函数

									implicit def add(x: Int)(y: Int): Int = x + y

这样，在需要两个Int类型参数的地方，就可以直接传入一个Int类型的值，编译器会自动调用隐式转换函数进行转换：

				?

									// 使用柯里化形式的隐式转换

									val z: Int = 10(20) // 相当于 val z: Int = add(10)(20)

									println(z) // 输出 30

隐式参数

隐式参数是指在定义方法时，方法中的部分参数是由implicit修饰的。

隐式参数的作用是可以让调用者省略掉一些不必要或者重复的参数，让代码更简洁和优雅。

隐式参数的定义是在方法签名中使用implicit关键字修饰某个或某些参数。

例如，下面定义了一个方法，它有两个参数，第一个是普通参数，第二个是隐式参数：

				?

									// 定义方法，其中一个参数是隐式参数

									def sayHello(name: String)(implicit greeting: String): Unit = {

									  println(s"$greeting, $name!")

									}

这样，在调用这个方法时，就不必手动传入第二个参数，Scala会自动在作用域范围内寻找合适类型的隐式值自动传入。

例如，下面定义了一个字符串类型的隐式值，并调用了上面定义的方法：

				?

									// 定义字符串类型的隐式值

									implicit val hi: String = "Hi"

									// 调用方法，省略第二个参数

									sayHello("Alice")

									// 相当于 sayHello("Alice")(hi)

									println(s"Hi, Alice!")

注意，如果在定义隐式参数时只有一个参数是隐式的，那么可以直接使用implicit关键字修饰参数，而不需要使用柯里化函数形式。

例如，下面定义了一个方法，它只有一个参数，且是隐式的：

				?

									// 定义方法，只有一个参数且是隐式的

									def sayBye(implicit name: String): Unit = {

									  println(s"Bye, $name!")

									}

这样，在调用这个方法时，就不需要创建类型不传入参数，Scala会自动在作用域范围内寻找合适类型的隐式值自动传入。

例如，下面定义了一个字符串类型的隐式值，并调用了上面定义的方法：

				?

									// 定义字符串类型的隐式值

									implicit val bob: String = "Bob"

									// 调用方法，不传入参数

									sayBye // 相当于 sayBye(bob)

									println(s"Bye, Bob!")

隐式类

隐式类是指在定义类时前面加上implicit关键字的类。

隐式类的作用是可以让一个类拥有另一个类的所有方法和属性，或者给一个类添加新的方法和属性。

隐式类的定义是在对象或者包对象中使用implicit关键字修饰类的声明。

例如，下面定义了一个隐式类，可以把String类型转换成拥有reverse方法的类：

				?

									// 定义隐式类

									object StringUtils {

									  implicit class StringImprovement(val s: String) {

									    def reverse: String = s.reverse

									  }

									}

这样，在需要使用reverse方法的地方，就可以直接传入一个String类型的值，编译器会自动调用隐式类的构造器进行转换：

				?

									// 使用隐式类

									import StringUtils._ // 导入隐式类所在的对象

									val s: String = "Hello"

									println(s.reverse) // 输出 olleH

注意，隐式类必须有且只有一个参数，并且参数类型不能是目标类型本身。

另外，如果在定义隐式类时使用了泛型参数，那么可以实现多种类型之间的转换：

				?

									// 定义泛型参数的隐式类

									object MathUtils {

									  implicit class NumberImprovement[T](val x: T)(implicit numeric: Numeric[T]) {

									    def plusOne: T = numeric.plus(x, numeric.one)

									  }

									}

这样，在需要使用plusOne方法的地方，就可以直接传入任何数值类型的值，编译器会自动调用隐式类的构造器进行转换：

				?

									// 使用泛型参数的隐式类

									import MathUtils._ // 导入隐式类所在的对象

									val x: Int = 10

									println(x.plusOne) // 输出 11

									val y: Double = 3.14

									println(y.plusOne) // 输出 4.14

隐式转换和隐式参数的导入

Scala提供了两种方式来导入隐式转换和隐式参数：手动导入和自动导入。

手动导入是指在需要使用隐式转换或者隐式参数的地方，使用import语句导入相应的对象或者包对象中定义的隐式内容。

例如，上面使用到的两个例子都是手动导入了StringUtils和MathUtils对象中定义的隐式内容。

手动导入的优点是可以控制导入的范围和精度，避免不必要的冲突和歧义。
手动导入的缺点是需要编写额外的代码，可能会增加代码的长度和复杂度。

自动导入是指在不需要使用import语句的情况下，Scala会自动在一些特定的位置寻找隐式转换或者隐式参数。

例如，Scala会自动导入以下位置定义的隐式内容：

当前作用域内可见的隐式内容与源类型或者目标类型相关联的隐式内容与隐式参数类型相关联的隐式内容

当前作用域内可见的隐式内容是指在当前代码块中定义或者引用的隐式内容。

例如，下面定义了一个隐式转换函数和一个隐式值，在当前作用域内可以直接使用：

				?

									// 定义当前作用域内可见的隐式内容

									implicit def doubleToInt(x: Double): Int = x.toInt

									implicit val pi: Double = 3.14

									// 使用当前作用域内可见的隐式内容

									val n: Int = pi // 相当于 val n: Int = doubleToInt(pi)

									println(n) // 输出 3

与源类型或者目标类型相关联的隐式内容是指在源类型或者目标类型的伴生对象中定义的隐式内容。

例如，下面定义了一个Person类和一个Student类，并在它们的伴生对象中分别定义了一个隐式转换函数，可以把Person转换成Student，或者把Student转换成Person：

				?

									// 定义Person类和Student类

									class Person(val name: String)

									class Student(val name: String, val score: Int)

									// 定义Person类的伴生对象，其中有一个隐式转换函数，可以把Person转换成Student

									object Person {

									  implicit def personToStudent(p: Person): Student = new Student(p.name, 0)

									}

									// 定义Student类的伴生对象，其中有一个隐式转换函数，可以把Student转换成Person

									object Student {

									  implicit def studentToPerson(s: Student): Person = new Person(s.name)

									}

这样，在需要使用Person或者Student类型的地方，就可以直接传入另一种类型的值，编译器会自动调用伴生对象中定义的隐式转换函数进行转换：

				?

									// 使用与源类型或者目标类型相关联的隐式内容

									def sayName(p: Person): Unit = {

									  println(s"Hello, ${p.name}!")

									}

									def sayScore(s: Student): Unit = {

									  println(s"Your score is ${s.score}.")

									}

									val alice = new Person("Alice")

									val bob = new Student("Bob", 100)

									sayName(alice) // 输出 Hello, Alice!

									sayName(bob) // 相当于 sayName(studentToPerson(bob))，输出 Hello, Bob!

									sayScore(alice) // 相当于 sayScore(personToStudent(alice))，输出 Your score is 0.

									sayScore(bob) // 输出 Your score is 100.

与隐式参数类型相关联的隐式内容是指在隐式参数类型的伴生对象中定义的隐式内容。

例如，下面定义了一个Ordering[Int]类型的隐式参数，并在它的伴生对象中定义了一个隐式值：

				?

									// 定义Ordering[Int]类型的隐式参数

									def max(x: Int, y: Int)(implicit ord: Ordering[Int]): Int = {

									  if (ord.gt(x, y)) x else y

									}

									// 定义Ordering[Int]类型的伴生对象，其中有一个隐式值

									object Ordering {

									  implicit val intOrdering: Ordering[Int] = new Ordering[Int] {

									    def compare(x: Int, y: Int): Int = x - y

									  }

									}

这样，在调用max方法时，就不需要手动传入第二个参数，Scala会自动在Ordering对象中寻找合适类型的隐式值自动传入：

				?

									// 使用与隐式参数类型相关联的隐式内容

									val a = 10

									val b = 20

									println(max(a, b)) // 相当于 println(max(a, b)(intOrdering))，输出 20