scala隐式转换

scala提供的隐式转换特性可以在效果上给一个类增加一些方法，或者用于接收不同类型的对象，然而使用scala的隐式转换是有一定的限制的，总结如下：
1. implicit关键字只能用来修饰方法、变量（参数)和伴随对象；
2. 隐式转换的方法（变量和伴随对象）在当前范围内才有效，如果隐式转换不在当前范围内定义（比如定义在另一个类中或包含在某个对象中），那么必须通过import语句将其导

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))
    //file类没有read方法，但在导入的域里找到了隐式方法
    println(new File("E:\\WangJialin.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))) //15
      println(sum(List("Scala", "Spark", "Kafka"))) //ScalaSparkKafka

  }
}  

隐式参数

//隐式参数
object Context_Implicits{
    implicit val default:String = "Flink"
}

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") //Flink:Hadoop
  }
}