Scala进阶之路-Scala高级语法之隐式(implicit)详解

　　　　　　　　　　Scala进阶之路-Scala高级语法之隐式(implicit)详解

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰

版权声明：原创作品，谢绝转载！否则将追究法律责任。

　　我们调用别人的框架，发现少了一些方法，需要添加，但是让别人为你一个人添加是不现实的，因此很多很多时候需要我们自己动手。掌握implicit的用法是阅读Spark源码的基础，也是学习Scala其它的开源框架的关键，implicit可分为隐式参数，隐式转换类型以及隐式类三种类型。

一.Scala中的隐士参数

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 EMAIL:[e-mail]
 */
 package cn.org.yinzhengjie.scalaImplicit

 object ScalaImplicit {

     /**
       *     定义一个隐式值，编译器在查找隐式值的时候，不能出现歧义，也就是说，编译器在编译代码的时候，不能找到
       * 两个类型一致的隐式值，不然编译器是会编译不通过的！
       */
     implicit val default:Int = 500

     /**
       * @param Name  : 此处我们将Name设置为隐士的参数
       */
     def sayHello(implicit Name:String = "YinZhengJie") = {
         println(s"I'm ${Name},I love Beijing !")
     }

     /**
       * @param x    : 柯里化函数(Currying)的第一个参数
       * @param y    ：柯里化函数(Currying)的第二个参数，其类型为一个隐式的参数哟
       * @return     : 返回值类型为Int
       */
     def add(x:Int)(implicit y:Int):Int={
         x + y
     }

     /**
       *     方法的参数如果有多个隐式参数的话，只需要使用一个implicit关键字即可，隐式参数列表必须放在方法的参数列表后面
       */
     def sum(a:Int)(implicit b:Int,c:Int):Int={
         a + b + c
     }

     def main(args: Array[String]): Unit = {

         sayHello("yinzhengjie")

         /**
           *     sayHello方法参数是隐式参数，如果你没有给sayHello传递参数的话，编译器在编译的时候会自动从当前的上下文中
           * 找一个隐式值(符合参数类型的隐式值)，如果有则使用，如果没有就使用sayHello方法参数的默认值,指的注意的是，当一
           * 各类中出现了多个implicit变量时，貌似默认值也不好使了！当前的类我就定了2个implicit变量就是一个很好的例子！
           */
 //        sayHello

         implicit val msg:String = "尹正杰"
         sayHello

         /**
           * 在调用柯里化函数(Currying)的时候，我们仅仅出入了第一个参数，第二个参数默认就是类中的成员变量用implicit修饰的default的值。
           */
         val res = add(20)
         println(s"res =====》 ${res}")

         /**
           * 本来需要传入3个参数的，但是我们就传了一个，其他两个参数就会默认使用类中的成员变量用implicit修饰的default的值。
           */
         val res2 = sum(10)
         println(s"res2 =====》 ${res2}")
     }
 }

 /*
 以上代码输出结果如下:
 I'm yinzhengjie,I love Beijing !
 I'm 尹正杰,I love Beijing !
 res =====》 520
 res2 =====》 1010
  */

二.Scala中的隐式类型转换

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 EMAIL:[e-mail]
 */
 package cn.org.yinzhengjie.scalaImplicit

 object ScalaImplicit {

     /**
       * 使用关键字implicit定义一个隐式方法。
       */
     implicit def doubleToInt(double: Double):Int = {
         println("====== 调用了方法:doubleToInt ======")
         double.toInt
     }
     /**
       * 使用关键字implicit定义一个隐式函数。
       */
     implicit val doubleToInt2 = (double:Double) => {
         println("====== 调用了函数:doubleToInt2 ======")
         double.toInt
     }

     def main(args: Array[String]): Unit = {

         /**
           *     year是一个Int类型的变量，但是赋值的确实一个浮点型数字，此刻编译器会在当前上下文中找一个
           * 隐式转换，找一个能把浮点型变成Int类型的隐式转换的函数或者方法，如果有函数实现了这个功能就优先
           * 调用函数的功能，若没有函数实现该功能就回去找是否有方法实现了该功能！如果函数或者方法都没有实现
           * 该功能编译器是会报错的！
           */
         val year:Int = 2018.7
         println(s"year的结果是: ${year}")
     }
 }

 /*
 以上代码输出结果如下:
 ====== 调用了函数:doubleToInt2 ======
 year的结果是: 2018
  */

三.Scala中的隐式类

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 EMAIL:[e-mail]
 */
 package cn.org.yinzhengjie.scalaImplicit

 import java.io.File

 import scala.io.Source

 object ScalaImplicit {
     /**
       * 定义隐式类，只能在静态对象(使用Object修饰)中使用
       */
     implicit class FileRead(file:File){
         def myRead() = Source.fromFile(file).mkString
     }

     def main(args: Array[String]): Unit = {
         val file = new File("D:\\10.Java\\IDE\\yhinzhengjieData\\Scala\\1.txt")
         val lineCounts =  file.myRead()
         println(s"file文件对象里面的内容如下:\n${lineCounts}")
     }
 }

 /*
 以上代码输出结果如下:
 file文件对象里面的内容如下:
 hello wolrd
 hello wolrd
 hello wolrd
 hello wolrd
 hello wolrd
 hello wolrd
 hello wolrd
 hello wolrd
 hello wolrd
 hello wolrd
 hello wolrd
 hello wolrd
 hello wolrd
 hello wolrd
 hello wolrd
 hello wolrd
 hello wolrd
 hello wolrd
  */

四.小试牛刀（封装File对象，新增lineCount方法，用来统计文件的行数，要求使用隐式方法）

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Scala%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 EMAIL:[e-mail]
 */
 package cn.org.yinzhengjie.scalaImplicit

 import java.io.{BufferedReader, File, FileReader}

 /**
   * 自定义一个RichFile类，封装File类
   */
 class RichFile(file:File){
     /**
       * 定义方法返回文件的记录行数
       */
     def linesCount():Int={
         val fileReader = new FileReader(file)
         val bufferReader = new BufferedReader(fileReader)

         var sum = 0
         try {
             var line = bufferReader.readLine()
             while (line != null) {
                 sum += 1
                 line = bufferReader.readLine()
             }
         } catch {
             case _: Exception => sum
         } finally {
             fileReader.close()
             bufferReader.close()
         }
         sum
     }
 }

 object ScalaImplicit {
     /**
       * 定义一个隐式方法，将File类型转换成RichFile类型。
       */
     implicit def fileToRichFile(file: File) = {
         new RichFile(file)
     }

     def main(args: Array[String]): Unit = {
         val file = new File("D:\\10.Java\\IDE\\yhinzhengjieData\\Scala\\1.txt")

        val lineCounts =  file.linesCount()
         println(s"file文件对象里面的行数是:${lineCounts}")
     }
 }

 /*
 以上代码输出结果如下:
 file文件对象里面的行数是:18
  */