scala学习笔记2-隐式转换implicit

一、 Scala隐式转换

    一个类实例A，有a方法而没有b方法，需要将A转换为提供b方法的类，称为隐式转换；

class RichFile(val file: File) {
     def read() = {
          Source.fromFile(file.getPath()).mkString
      }
 }              
object Context {
     implicit def file2RichFile(file: File) = new RichFile(file)
 }            
object HelloImplicit {
     def main(args: Array[String]): Unit = {
         import Context.file2RichFile //导入隐式转换
         val file = new File("")
         println(file.read()) // File -->RichFile
      }
}

    隐式转换在spark RDD的应用

       rddToPairRDDFunctions、rddToAsyncRDDActions、rddToSequenceFileRDDFunctions等，这些是定义的隐身转换，将RDD分别转为PairRDDFunctions(rdd)、AsyncRDDActions(rdd)等，提供更多的api

       在Spark RDD中的以上这些隐式转换，在1.3之前是通过import SparkContext._导入的，之后直接移到了object RDD{}中（即RDD的伴生对象），使得编译器能够自动识别到，而不用像上列中那样手动导入：

      将隐式转化方法写到对应类的伴生对象中，如下：

class FileImplicit(path: String) extends File(path) //需要指定继承file哪个构造方法
object FileImplicit{ // 在伴生对象中写入隐式方法，编译器就可以自动识别隐式转换，而不要手动导入
   implicit def file2RichFile(file: File) = new RichFile(file)
}
println(new FileImplicit("D:\\webdata\\index.php").read())

二、 scala隐式参数和隐式转换

     隐式参数下的隐式转换，将一个类型T隐式转为其他类型，例如implicit ordered : T => Ordered[T]

    代码示例：

//将T类型隐式转换为Ordered[T]，从而具有 > 方法
def bigger[T](a : T, b : T)(implicit ordered : T => Ordered[T]) = {
   if(a > b) a else b
}
println(bigger(3,4))

三、 scala上下文界定的隐式转换

     [T :Ordering]表示上下文界定的隐式转换，变为Ordering[T]

    示例：  

class Test[T : Ordering](val first : T, val second : T) { //Ordering[T]
     def bigger(implicit ord : Ordering[T]) = {
         if(ord.compare(first,second) > 0) first else second
     }
     def bigger2() = {
         import Ordered.orderingToOrdered //把Ordering[T] => Ordered[T]
         if(first >second) first else second //这个>方法是Ordered中
     }
     def bigger3() = {
         if(implicitly[Ordering[T]].compare(first,second) > 0) first else second
     }
}

四、  Scala隐式类

       导入隐式类，使得在当前的上下文作用域中的原始类型的得到增强：

object ContextHelper{
    implicit class Operate(one : Int) {//隐式类
        def add(second : Int) = {
             one + second
         }
     }
     implicit class FileRich(file : File) {
       def lala() = file.getName
     }
}
           
object ImplicitClass {
   def main(args: Array[String]): Unit = {
        import ContextHelper._ //在当前作用域导入隐式类
        println(1.add(2))// 扩展了整数的方法，使得Int具有add方法
        println(newFile("d:\\a.txt").lala()) //扩展了文件的方法，使得File的具有lala方法
   }
}

五、 Scala隐式对象

trait Template[T] { //接口Template
   def add(x:T, y:T):T
}
         
trait SubTemplate[T] extends Template[T] { //子接口SubTemplate
   def unit() : T
}
         
object ImplicitObject {//implict不是top-level级别的修饰(如class,trait,object等)
            
   implicit object StringAdd extends SubTemplate[String] {//隐式对象
       def add(x:String,y:String) : String = x.concat(y)
       def unit() : String =""
    }
          
    implicit object IntAdd extends SubTemplate[Int] {//隐式对象
        def add(x:Int, y:Int) :Int = x + y
        def unit() : Int = 0
    }
           
    sum方法， 其中根据T的类型隐式转换为对应的m
    def sum[T](list :List[T])(implicit m : SubTemplate[T]) : T = {
       if(list.isEmpty) m.unit()
       else m.add(list.head, sum(list.tail))
    }
           
    def main(args: Array[String]): Unit = {
       println(sum(List(1,2,3,4,5)))
       println(sum(List("coder","sh")))
     }
 }