Explanation and practice of implicit transformation and implicit parameters in Scala

brief introduction ：

Scala Implicit conversion and implicit parameter function provided by , It's a very distinctive function . yes Java And other functions that programming languages don't have . It allows you to manually specify to convert objects of one type to objects of other types , Or add a method to a class . Through these functions , Can achieve very powerful functions .

1、 Implicit conversion

The core of implicit transformation is to define a usage implicit Methods of keyword modification , The implementation converts an original class into a target class , So you can call methods in the target class , Is it powerful . The method of implicit transformation needs to be defined in a object in .

Example 1 ： Transform the third-party library class , Give Way File Class owned RichFile Class read Method

import java.io.Fileimport scala.io.Sourceobject ExecFileDef {  // Define a method of implicit transformation , Realize the File convert to RichFile  implicit def file2RichFile(file: File) = new RichFile(file)}//  Expand file class class RichFile(val file: File){  // Method of reading data file   def read():String={    Source.fromFile(file).mkString  }}object RichFile{  def main(args: Array[String]): Unit = {    //1、 Construct a File object     val file = new File("F:\\acc.txt")    //2、 Manually import implicit conversions     import ExecFileDef.file2RichFile    // At this time file Has been transformed ,  have access to read Method     val data: String = file.read    println(data)  }}

Example 2 ： Use implicit conversions for classes you define , Ordinary people become big men

class AveragePerson(val name: String)class Mogul(val name: String) {  def come(): Unit = {    println(" bosses  "+ name + "  coming , Applause reminds me of , Bring your own halo , Crazy money ！")  }}object TransformExec {  implicit def AveragePerson2Mogul(averagePerson: AveragePerson): Mogul = {    new Mogul(averagePerson.name)  }  def main(args: Array[String]): Unit = {    val mogul = new AveragePerson(" Orange garden ")    mogul.come()  }}

result ：

Example 3 ： A class implicitly converts a class with the same method

class Aclass B(a: A) {  def readBook(): Unit ={    println("B read ")  }}class C(a: A){  def readBook(): Unit ={    println("C read ")  }  def writeBook(): Unit ={    println("C To write a book ")  }}object BC{  // Create a class to convert to 2 Implicit conversion of classes   implicit def A2B(a: A)=new B(a)  implicit def A2C(a: A)=new C(a)}object C{  def main(args: Array[String]) {    // Guide pack     //import BC._  This will AB All implicit transformations under the class are imported     //import BC.A2B  Import only A Class to B Class     //import BC.A2C  Import only A Class to C Class     import BC._    val a = new A    // because B Class and C Classes have readBook(), Only one of them can be imported , Otherwise, the code will report an error when calling a common method     //a.readBook()    //A Class can execute C Class writeBook()    a.writeBook()  }}

result ：

2、 Implicit parameter

It means in a function or method , Define a with implicit Modified parameters , here Scala Will try to find a specified type of implicit Modified parameters , That is, the implicit value , And injection parameters . Implicit parameters also need to be defined in a object in .

Example ： Use of implicit parameters , The boss gives money to his employees

object Company{  // Be careful ： Implicit values of the same type are allowed only once , Otherwise, an error will be reported   implicit val name: String = " Orange garden "  implicit val salary: Double = 100000.0  // If it occurs again, an error will be reported   //implicit val zzz: String=" Orange ape "}class Boss {  // Define a with implicit The decorated parameter type is String  // Note the type of parameter matching , What it needs is String Implicit value of type   def callName(implicit name: String): String={    name  }  // Define a with implicit Modified parameters , The type is Double  // Note the type of parameter matching , What it needs is Double Implicit value of type   def getMoney(implicit money: Double): String={    money.toString  }}object Boss extends App{  // Use import Import defined implicit values , Be careful ： It must be loaded first, or an error will be reported   import Company.name  import Company.salary  val boss = new Boss  println(boss.callName + ":" + boss.getMoney)}

result ：