Scala隐式转换

隐式转换

隐式转换增强现有类型

import scala.io.Source

//RichFile相当于File增强类,需要将被增强的类作为参数传入增强类构造器中
class RichFile(filePath :String){
  def read():String = {
    Source.fromFile(filePath).mkString
  }
}
//implicit定义一个隐式转换函数把被增强类型转换成增强的类型
object MyPredef{
  //File --> RichFile
  implicit val filePath2File = (filePath:String) => new RichFile(filePath)
}
object HelloImplicitConversions {
  def main(args: Array[String]): Unit = {
    val filePath = "c://cc//cc.txt"
    //导入隐式转换
    import MyPredef._
    //String类本身没有read(),隐式转换为RichFile类调用的read()
    filePath.read
  }
}

隐式参数

object Param{
  def printA(context:String)(implicit default:String) = println(context + default)
}
object MyPreder{
  //定义隐式参数
  implicit val default:String = "在吃饭"
}
object ImplictParameters {
  def main(args: Array[String]): Unit = {
    //隐式参数可以正常传值
    Param.printA("天金")("在喝水")
    //隐式参数没有传值，编译器会在全局范围内搜索implicit String类型的隐式值传入
    import MyPreder._
    Param.printA("李赤")
  }
}

隐式参数隐式转换

object ImplicitConversionswithImplicitParameters {
  def main(args: Array[String]): Unit = {
    // 柯里化的泛型方法everythingCompare
    // 第二个括号传入的是一个匿名函数,类型为T => Ordered[T]
    // 传入隐式参数,输入类型为T类型,返回类型为Ordered[T]类型
    def everythingCompare[T](a:T, b:T)(implicit e:T => Ordered[T]):T = {
      //ordered(a) > b
      //if(e(a) > b) a else b
      if(a > b) a else b
    }
    println(everythingCompare(4, 3))
    println(everythingCompare("Shangtj", "LiheChi"))
  }
}

隐式类（少）

有时候进行代码重构，要增强他的某项功能同时又不想做太大的改动

import scala.io.Source

object Context_helper{
  implicit class FilePath2File(filePath:String){
    def read:String = Source.fromFile(filePath).mkString
  }
  implicit class OpAdd(x:Int){
    def add(y:Int):Int = x + y
  }
}
object ImplicitsClass {
  def main(args: Array[String]): Unit = {
    import Context_helper._
    val fn = "d://myFile//ff.md"
    println(fn.read)
    println(1.add(2))
  }
}

隐式对象

abstract class Template[T]{
  def add(x:T, y:T):T
}
abstract class SubTemplate[T] extends Template[T]{
  def unit:T
}

object ImplicitsObject {
  implicit object StringAdd extends SubTemplate[String]{
    override def add(x: String, y: String): String = x concat y
    override def unit: String = ""
  }
  implicit object IntAdd extends SubTemplate[Int]{
    override def add(x: Int, y: Int): Int = x + y
    override def unit: Int = 0
  }
  //im是隐式对象
  def sum[T](list :List[T])(implicit im:SubTemplate[T]):T = {
    if(list.isEmpty) im.unit
      //list.tail除第一个元素外其他元素
    else im.add(list.head, sum(list.tail))
  }
  def main(args: Array[String]): Unit = {
    println(sum(List(1, 2, 3)))
    println(sum(List("A", "B", "C")))
  }
}

也可以用来做参数类型转换

implicit def object2SpecialPerson(obj : Object) : SpecialPerson = {
    obj match{
      case a : Student => {val stu = obj.asInstanceOf[Student];new SpecialPerson(stu.name)}
      case b : Older =>{val old = obj.asInstanceOf[Older];new SpecialPerson(old.name)}
      case _ => Nil
    }
  }

上下文界定中的隐式参数

在每次上下文运行的实例对象中将具体的值注入到隐式参数中，而且注入的过程是自动的

//[T: Ordering]：说明存在一个隐式类型Ordering[T]
class Pair_Implicits[T: Ordering](val a: T, val b: T){
  //声明一个隐式类型对象传入函数
  def bigger(implicit ordered: Ordering[T]) = {
    if (ordered.compare(a, b) > 0) a else b
  }
}
object ContextBoundsInternals {
  def main(args: Array[String]): Unit = {
    new Pair_Implicits(1, 2).bigger
  }
}