在 GitHub 上编辑此页面

隐式转换

隐式转换，也称为视图，是编译器在几种情况下应用的转换

当遇到类型为 T 的表达式 e 时，但编译器需要类型为 S 的表达式。
当遇到表达式 e.m 时，其中 e 的类型为 T，但 T 未定义成员 m。

在这些情况下，编译器会在隐式作用域中查找可以将类型为 T 的表达式转换为类型为 S 的表达式（或在第二种情况下转换为定义成员 m 的类型）的转换。

此转换可以是

类型为 T => S 或 (=> T) => S 的 implicit def
类型为 scala.Conversion[T, S] 的隐式值

定义隐式转换将发出警告，除非隐式作用域中包含导入 scala.language.implicitConversions，或者向编译器提供标志 -language:implicitConversions。

示例

第一个示例取自 scala.Predef。由于此隐式转换，可以将 scala.Int 传递给期望 java.lang.Integer 的 Java 方法。

import scala.language.implicitConversions
implicit def int2Integer(x: Int): java.lang.Integer =
  x.asInstanceOf[java.lang.Integer]

第二个示例展示了如何使用 Conversion 为任意类型定义 Ordering，前提是已知其他类型的 Ordering。

import scala.language.implicitConversions
implicit def ordT[T, S](
    implicit conv: Conversion[T, S],
             ordS: Ordering[S]
   ): Ordering[T] =
   // `ordS` compares values of type `S`, but we can convert from `T` to `S`
  (x: T, y: T) => ordS.compare(x, y)

class A(val x: Int) // The type for which we want an `Ordering`

// Convert `A` to a type for which an `Ordering` is available:
implicit val AToInt: Conversion[A, Int] = _.x

implicitly[Ordering[Int]] // Ok, exists in the standard library
implicitly[Ordering[A]] // Ok, will use the implicit conversion from
                        // `A` to `Int` and the `Ordering` for `Int`.

更多细节