Scala 中的隐式转换

Scala 中的隐式转换是在使用错误类型的对象时应用的一组方法。它允许编译器自动将一种类型转换为另一种类型。
隐式转换适用于两种情况：

• 首先，如果类型 A 和 S 的表达式与预期的表达式类型 B 不匹配。
• 其次，在类型 A 的表达式 e 的选择 em 中，如果选择器 m 不代表 A 的成员。

在第一个条件中，搜索适合于表达式且其结果类型与 B 匹配的转换。在第二个条件中，搜索适合于表达式且其结果带有名为 m 的成员的转换。
现在，让我们通过一个例子来理解。
对 List[Int] 类型的两个列表 xa 和 ya 的以下操作是合法的：

xa = ya

假设隐式方法 listorder 和 intorder 在范围内定义如下：

implicit def listorder[A](x: List[A]) 
(implicit elemorder: A => Ordered[A]): Ordered[List[A]] = 
new Ordered[List[A]] { /* .. */ } 
implicit def intorder(x: Int): Ordered[Int] = 
new Ordered[Int] { /* .. */ }

让我们看一个例子。
例子 ：

Scala

// Scala program of implicit conversions
import A.fromString
import scala.language.implicitConversions
  
case class A(s: String)
object A
{
    // Using implicitConversions   
    implicit def fromString(s: String): A = A(s)
}
  
class C
{
  def m1(a: A) = println(a)
  def m(s: String) = m1(s)
}
  
// Creating object
object C
{
    // Main method
    def main(args: Array[String])
    {
        var b : A = ("GeeksforGeeks")
         println(b)
      
    }
}

输出 ：

A(GeeksforGeeks)

如果随机使用隐式转换有一个缺点，编译器在编译隐式转换定义时会发出警告。
为了避免警告，我们需要采取以下两个步骤之一：

• 将 scala.language.implicitConversions 导入隐式转换定义的范围。
• 使用 -language:implicitConversions 调用编译器。

现在，让我们看另一个例子。
例子 ：

斯卡拉

// Scala program of implicit conversions
import ComplexImplicits._
 
object ComplexImplicits
{
    // implicit conversion
    implicit def DoubleComplex(value : Double) =
                        new Complex(value,0.0)
     
    implicit def TupleComplex(value : Tuple2[Double,Double]) =
                        new Complex(value._1,value._2);
 
}
 
// Creating a class containing different method
class Complex(val r : Double, val i : Double)
{
     
    def +(that: Complex) : Complex =
    (this.r + that.r, this.i + that.i)
     
    def -(that: Complex) : Complex =
    (this.r - that.r, this.i + that.i)
         
    def unary_~ = Math.sqrt(r * r + i * i)
         
    override def toString = r + " + " + i + "i"
     
}
 
// Creating Object
object Complex
{
     
val i = new Complex(0,1);
 
// Main method   
def main(args : Array[String]) : Unit =
{
    var a : Complex = (6.0,4.0)
    var b : Complex = (1.0,2.0)
    println(a)
    println(a + b)
    println(a - b)
    println(~b)
         
    var c = 5 + b
    println(c)
    var d = (3.0,3.0) + c
    println(d)
}
}

输出 ：

6.0 + 4.0i
7.0 + 6.0i
5.0 + 6.0i
2.23606797749979
6.0 + 2.0i
9.0 + 5.0i