scala隐式转换（二十三）

scala隐式转换分为隐式方法、隐式参数、隐式类及隐式对象。

隐式方法

方法命名：文件名为源文件名2目标文件名，例如：file2RichFile定义隐式转换的方法名。

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

object Context {
    /*
     * 隐式转换必须有：implicit关键字，需要和输入参数类型一致
     *
     */
    implicit def file2RichFile(file: File) = new RichFile(file)
}

object HelloImplicitConversions {
    def main(args: Array[String]): Unit = {
        //导入方法
        import Context.file2RichFile

        /*
         * 查找可以使用的隐式转换，调用read方法。
         * 查找：先从当前类中查找，如果没有再从伴生对象中查找有implicit关键字且参数一致的函数。
         */
         println(new File("E:\\input.txt").read);
    }
}

隐式参数

隐式参数：在参数前添加implicit关键字的参数。

//伴生对象
object ContextImplicits {
    implicit val default: String = "Java"
}

//伴生对象
object Param {
    //自定义print方法，定义implicit language:String隐式参数
    def print(content: String)(implicit language: String) {
        println(language + ":" + content)
    }
}

object ImplicitParameters {
    def main(args: Array[String]): Unit = {
        //执行结果: Scala:Spark
        Param.print("Spark")("Scala")

        //引入指定的字段
        import ContextImplicits.default
        //执行结果： Java:Hadoop
        Param.print("Hadoop")
    }
}

函数类型的隐式参数

def main(args: Array[String]): Unit = {
    def bigger[T](a: T, b: T)(implicit ordered: T => Ordered[T]) = 
        //比较大小，返回较大的值
        if (ordered(a) > b) a else b
}

上下文界定隐式参数

class PairImplicits[T: Ordering](val first: T, val second: T) {
    //ordered隐式值。比较大小，返回结果
    def bigger(implicit ordered: Ordering[T]) = 
        if (ordered.compare(first, second) > 0) first else second
}

class PairImplicitly[T: Ordering](val first: T, val second: T) {
    //implicitly关键字：提取运行时上下文界定的实例值
    def bigger = if (implicitly[Ordering[T]].compare(first, second) > 0) first else second
}

class PairImplicitlyOrdered[T: Ordering](val first: T, val second: T) {
    def bigger = {
        //引用Ordered下所有的类
        import Ordered._
        //>函数，使用隐式转换成Ordered类型进行比较
        if (first > second) first else second
    }
}

//代码调用实现
object ContextBoundsIntemals {
    def main(args: Array[String]): Unit = {
        //执行结果：9
        println(new PairImplicits(7,9).bigger)
        //执行结果：9
        println(new PairImplicitly(7,9).bigger)
        //执行结果：9
        println(new PairImplicitlyOrdered(7,9).bigger)
    }
}

隐式类

隐式类：在class关键字前带有implicit关键字的类。

object ContextHelper {

    implicit class FileEnhancer(file: File) {
        def read = Source.fromFile(file)
    }

    implicit class Calculator(x: Int) {
        def add(second: Int) = x + second
    }

}

object ImplicitsClass {
    def main(args: Array[String]): Unit = {
        //导入ContextHelper伴生对象中所有的隐式类
        import ContextHelper._

        print(1.add(100))

        var lines = new File("E:\\input.txt").read
        lines.foreach(print(_))
    }
}

隐式对象

隐式对象：在object关键字前带有implicit关键字的伴生对象。

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] {
        def add(x: String, y: String): String = x + " " + y
        def unit: String = ""
    }

    implicit object IntAdd extends SubTemplate[Int] {
        def add(x: Int, y: Int): Int = x + y
        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))
        }


    def main(args: Array[String]): Unit = {
        //执行结果：15
        println(sum(List(1,2,3,4,5)))

        //执行结果：C C++ Java Scala
        println(sum(List("C","C++","Java","Scala")))

    }
}

忠于技术，热爱分享。欢迎关注公众号：java大数据编程，了解更多技术内容。

这里写图片描述