Scala进阶源码实战之八——隐式转换和隐式参数

隐式转换

import scala.io.Source
import java.io.File

class RichFile(val file:File){
   def read = Source.fromFile(file.getPath()).mkString
}

object Context{
    implicit def file2RichFile(file:File)= new RichFile(file) //File -> RichFile
}
object Hello_Implicit_Conversions {


//在伴生对象和作用域中找隐式转换
  def main(args: Array[String]) {
      import Context.file2RichFile
      println(new File("test.txt").read)  
  }
}

隐式参数

object Context_Implicits{
    implicit val default:String = "Java"
}

object Param{
    //第二个参数为隐式值，作为默认参数，如果不传入，就寻找隐式值
    //柯里化方式
   def print(content:String)(implicit language:String){
      println(language+":"+content)
   }
}
object Implicit_Parameters {

  def main(args: Array[String]) {
    Param.print("Spark")("Scala")  //Scala:Spark

    import Context_Implicits._
    Param.print("Hadoop")           //Java:Hadoop
  }
}


object Implicit_Conversions_with_Implicit_Parameters {

  def main(args: Array[String]) {
    //隐式参数下的隐式转换
    //ordered为一个函数
    def bigger[T](a: T, b: T)(implicit ordered: T => Ordered[T])
        = if (a > b) a else b   //等价于if (ordered（a）> b) a else b
    println(bigger(4,3))
    println(bigger(4.2,3))
    println(bigger("Spark","Hadoop"))
  }

}

上下文界定内幕中的隐式参数与隐式参数
class Pair_Implicits[T: Ordering](val first: T, val second: T){ //Ordering[T]
  def bigger(implicit ordered: Ordering[T]) =
    if (ordered.compare(first, second) > 0) first else second
}
class Pair_Implicitly[T: Ordering](val first: T, val second: T){
    def bigger =if (implicitly[Ordering[T]].compare(first, second) > 0) 
            first else second
}
class Pair_Implicitly_Odereded[T: Ordering](val first: T, val second: T){
    def bigger ={
      import Ordered._
      if (first > second) first else second
    }   
}
object Context_Bounds_Internals {

  def main(args: Array[String]){
    println(new Pair_Implicits(7, 9).bigger)
    println(new Pair_Implicitly(7, 9).bigger)
    println(new Pair_Implicitly_Odereded(7, 9).bigger)

  }

}

隐式类

 import java.io.File

import scala.io.Source
object Context_Helper{  
    implicit class FileEnhancer(file : File){    
        def read = Source.fromFile(file.getPath).mkString  
    }
    implicit class Op(x:Int){
         def addSAP(second: Int) = x + second
    }
}
object Implicits_Class {

  def main(args: Array[String]){
    import Context_Helper._
    println(1.addSAP(2))
    println(new File("test.txt").read)   

  }

}

隐式对象

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

  def main(args: Array[String]) {
      implicit object StringAdd extends SubTemplate[String] {
        override def add(x: String, y: String) = x concat y
        override def unit: String = ""
      }
      implicit object IntAdd extends SubTemplate[Int] {
        override def add(x: Int, y: Int) = x + y
        override def unit: Int = 0
      }
      def sum[T](xs: List[T])(implicit m: SubTemplate[T]): T =
        if (xs.isEmpty) m.unit
        else m.add(xs.head, sum(xs.tail))

      println(sum(List(1, 2, 3, 4, 5)))
      println(sum(List("Scala", "Spark", "Kafka")))

  }

}