scala隐式參數、隐式函數、隐式類詳解

scala關鍵字"implicit"詳解

• 隐式參數
• • 定義
  • 示例
• 隐式函數
• • 定義
  • 示例
  • • 類型轉換
    • 類型增強
• 隐式類
• • 定義
  • 示例

隐式參數

定義

1、定義一個普通變量，使用 implicit 關鍵字修飾，定義一個函數調用這個變量當參數時，此時這個參數就被稱為隐式參數

2、隐式參數的作用：減少提供函數參數的數量，讓某些參數擁有隐藏的值（隐式變量）

示例

def main(args: Array[String]): Unit = {
   //隐式參數(每種類型隻能有一個)
    implicit var a:Int = 10
    implicit var str:String = "hello"

    def fun(a:Int,b:Int)(implicit c:Int=5):Int={
      a+b+c
    }
    def fun2(a:Int,b:Int)(c:Int):Int={
      a+b+c
    }
    def fun3(a:Int,b:Int)(implicit c:Int=5,str:String):Int={
      println(str)
      a+b+c
    }
    //優先級：傳參  >  隐式參數  >  預設
    println("fun結果："+fun(10,10))   //30 調用隐式參數10   //25  預設指派5
    println("fun結果："+fun(10,10)(20)) //40 傳參20
    println("fun2結果："+fun2(10,10)(20))
    println("fun3結果："+fun3(10,10))
    println("fun3結果："+fun3(10,10)(20,"heheda"))
}
           

注：

• 1、這裡定義的變量名是 a，但是傳入到函數當中，隐式參數名可以不為 a，随便起什麼名字都可以，隻要是 Int 類型就可以
• 2、在一個類中，定義同一類型的隐式參數隻能有一個，即函數參數清單中同一類型的隐式參數也隻能為一個，多了會打架，比如定義了兩個Int類型的變量當參數，implicit val a:Int = 10, implicit val b:Int = 20 ,傳入到函數中scala編譯就不知道用哪個參數了
• 3、在一個類中，不同類型的隐式參數可以傳入到函數當中
• 4、scala中函數的傳參級别： 函數清單傳參 > 隐式參數 > 預設值

隐式函數

定義

1、隐式函數也稱隐式轉換，使用implicit修飾的函數

2、作用：可以通過一個隐式函數将一種類型轉變為另一種類型

3、隐式轉換有兩種應用場景：

• a）類型轉換，隐式轉換為期望類型
• b）類型增強

示例

類型轉換

在scala中定義一個隐式函數，函數體是将傳入的 Double 類型使用 toInt 方法轉為 Int 類型

def main(args: Array[String]): Unit = {
    //隐式函數
    //類型轉換：Double --> Int
    implicit def DoubleToInt(a: Double) = {a.toInt}  //定義隐式函數

    val x: Int = 3.5 //寫的時候scala就調用了隐式函數 doubleToInt 進行類型轉化
    println(x)
}
           

常用的類型轉換:

implicit def doubleToString (obj:Double):String=obj.toString 
implicit def intToString(obj:Int):String=obj.toString 
implicit def stringToInt(obj:String):Int=Integer.parseInt(obj)
           

類型增強

定義一個隐式函數，使 “true=1，false=0” ,此時便可提供一個隐式函數，使得Int+Boolean成立

def main(args: Array[String]): Unit = {
    //隐式函數
   //類型增強
    implicit def BooleanToInt(x:Boolean) = if(x) 1 else 0
    println(1+true)
    println(1+false)
}
           

注： 隐式轉換的發生時機

• 1、當方法中的參數的類型與目标類型不一緻時
• 2、當對象調用類中不存在的方法或成員時，編譯器會自動将對象進行隐式轉換

隐式類

定義

1、隐式類指的是用implicit關鍵字修飾的類。

2、在對應的作用域内，帶有這個關鍵字的類的主構造函數可用于隐式轉換。

示例

package nj.zb.kb09.implicitdemo

class Demo2{

}

object Demo2 {
  def main(args: Array[String]): Unit = {
    //導包
    import nj.zb.kb09.implicitdemo.Impliciteg2._
    val demo2 = new Demo2
    demo2.aa("abc")
    println(demo2.add(12, 12))
    println(demo2.bb(3))
    println(demo2.login("zs", "123"))
  }
}
           

package nj.zb.kb09.implicitdemo

object Impliciteg2 {

  implicit class Demo2Implicit(demo2:Demo2) {
    def aa(s: String): Unit = {
      println(s)
    }

    def bb(num: Int):String = {
      if (num % 2 == 0) "偶數"else "奇數"
    }

    def add(num1: Int, num2: Int): Int = {
      num1 + num2
    }
  }
  implicit class Demo2Implicit2(demo2:Demo2){
    def login(name:String,pwd:String):Boolean={
      if (name.equals("zs") && pwd.equals("123")) true else false
    }
  }
}
           

參考部落格：https://blog.csdn.net/and52696686/article/details/107618593