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")))
}
}