Scala隐式转换和隐式参数详解

// 定义隐式转换函数
implicit def intToString(x: Int): String = x.toString

// 使用隐式转换
val s: String = 123 // 相当于 val s: String = intToString(123)
println(s.length) // 输出 3

// 定义柯里化形式的隐式转换函数
implicit def add(x: Int)(y: Int): Int = x + y

// 使用柯里化形式的隐式转换
val z: Int = 10(20) // 相当于 val z: Int = add(10)(20)
println(z) // 输出 30

// 定义方法，其中一个参数是隐式参数
def sayHello(name: String)(implicit greeting: String): Unit = {
  println(s"$greeting, $name!")
}

// 定义字符串类型的隐式值
implicit val hi: String = "Hi"

// 调用方法，省略第二个参数
sayHello("Alice")
// 相当于 sayHello("Alice")(hi)
println(s"Hi, Alice!")

// 定义方法，只有一个参数且是隐式的
def sayBye(implicit name: String): Unit = {
  println(s"Bye, $name!")
}

// 定义字符串类型的隐式值
implicit val bob: String = "Bob"

// 调用方法，不传入参数
sayBye // 相当于 sayBye(bob)
println(s"Bye, Bob!")

// 定义隐式类
object StringUtils {
  implicit class StringImprovement(val s: String) {
    def reverse: String = s.reverse
  }
}

// 使用隐式类
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)
  }
}

// 使用泛型参数的隐式类
import MathUtils._ // 导入隐式类所在的对象

val x: Int = 10
println(x.plusOne) // 输出 11

val y: Double = 3.14
println(y.plusOne) // 输出 4.14

// 定义当前作用域内可见的隐式内容
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类
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)
}

// 使用与源类型或者目标类型相关联的隐式内容
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]类型的隐式参数
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
  }
}

// 使用与隐式参数类型相关联的隐式内容
val a = 10
val b = 20
println(max(a, b)) // 相当于 println(max(a, b)(intOrdering))，输出 20