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
 */