/
* 隐式方法/隐式函数*：悄悄的将一个类型转为另一个类型
 语法: implicit def 方法名(参数名:待转换类型):目标类型 = {….}
隐式方法的调用时机:
在当前作用域内寻找有没隐式函数：
 1、当前类型与目标类型不一致的时候会自动调用隐式转换方法
* 2、对象使用了不属于自身的属性与方法/函数的时候会自动调用隐式转换方法

  1. *    **隐式参数**:后期在调用方法的,scala会自动传参<br />作用：<br />避免重复定义相同参数<br />![image.png](https://cdn.nlark.com/yuque/0/2021/png/21361442/1622958100145-a4265072-05ed-4aa6-a2d2-a9ba0d2a70db.png#id=XSZlk&margin=%5Bobject%20Object%5D&name=image.png&originHeight=281&originWidth=453&originalType=binary&ratio=1&size=68452&status=done&style=none)<br />语法:<br />    *           1、定义方法: def 方法名(参数:类型,..)(implicit 参数名:参数类型)= {方法体}<br />    *           2、定义参数: implicit val 参数名:类型 = 值，<br />也可以将该参数定义在类中
  1. *    **隐式类**: 将一个类型转换为指定类型<br />    *           语法: implicit class 类名(属性名:待转换类型){...}<br />    *           隐式类必须放在object/class中,不能置于最顶层
  1. *** 隐式转换的解析**:<br />    *     1、首先会从当前作用域查找是否有符合要求的隐式转换,如果有直接使用<br />    *     2、如果在作用域外定义隐式转换类，需要import 该类来使用<br />之前的import都是导入包，这里是导入类<br />    *           1、如果隐式转换定义在其他的object中,此时要想使用隐式转换需要导入: import object名称._ /import object名称.隐式转换名称<br />    *           2、如果隐式转换定义在class中,此时要想使用隐式转换,首先需要创建class对象,然后通过: import 对象名._ / import 对象名.隐式转换名称<br />    *       如果符合要求的隐式转换有多个,在导入的时候需要明确指定使用哪个隐式转换【import object名称.隐式转换名称】<br />    */

隐式转换函数

当前作用域隐式转换

  1. package tcode.chapter10
  3. import java.io.File
  4. import scala.io.Source
  5. import com.atguigu.chapter01.implictObject._
  6. import com.atguigu.chapter10.$01_ImplicitFunction.RichFile
  7. import tcode.chapter10.$01_ImplicitFunction.RichFile
  9. class implictObject2{
  11. object $01_ImplicitFunction {
  13.   class RichFile(file:File){
  15.     def getLine():Iterator[String] = {
  16.       Source.fromFile(file,"utf-8").getLines()
  17.     }
  18.   }
  20.   def main(args: Array[String]): Unit = {
  22.     // 这里d是Int型，但是传入值是double型，需要隐式转换
  23.     val d:Int = 10.0
  24.     println(d)
  27.     val file = new File("d:/data.txt")
  28.     file.getLine().foreach(x=>println(x))
  29.   }
  31.       // 当前作用域（object $01_ImplicitFunction）的定义隐式方法
  32.         implicit def file2RichFile(file:File):RichFile = {
  33.     new RichFile(file)
  34.       }
  35. }

导入object隐式对象的隐式转换

  1. // 隐式转换对象
  2. object implictObject{
  3.   implicit def file2RichFile(file:File):RichFile = {
  4.     new RichFile(file)
  5.   }
  6. }
  8. object $01_ImplicitFunction {
  9.   class RichFile(file:File){
  10.     def getLine():Iterator[String] = {
  11.       Source.fromFile(file,"utf-8").getLines()
  12.     }
  13.   }
  15.   def main(args: Array[String]): Unit = {
  16.     // 因为是object，提供的是静态方法所以可以直接导入使用object
  17.     import implictObject.file2RichFile
  19.     val file = new File("d:/data.txt")
  20.     file.getLine().foreach(x=>println(x))
  21.   }
  23. }

导入class隐式类的隐式转换

  1. // 隐式转换对象
  2.  class implictObject{
  3.   implicit def file2RichFile(file:File):RichFile = {
  4.     new RichFile(file)
  5.   }
  6. }
  8. object $01_ImplicitFunction {
  9.   class RichFile(file:File){
  10.     def getLine():Iterator[String] = {
  11.       Source.fromFile(file,"utf-8").getLines()
  12.     }
  13.   }
  15.   def main(args: Array[String]): Unit = {
  16.     // 因为是Class所以需要new对象才能使用隐式类的方法。
  17.     val implictClass = new implictObject
  18.     import implictObject.file2RichFile
  20.     val file = new File("d:/data.txt")
  21.     file.getLine().foreach(x=>println(x))
  22.   }
  24. }

隐式转换参数

作用域内的隐式参数

  1. package tcode.chapter10
  3. object $02_ImplicitParam {
  5.   /**
  6.     * 隐式转换参数: 后期在调用方法的,scala会自动传参
  7.     *   语法:
  8.     *       1、定义方法: def 方法名(参数:类型,..)(implicit 参数名:参数类型)= {方法体}
  9.     *       2、定义参数: implicit val 参数名:类型 = 值
  10.     */
  11.   def main(args: Array[String]): Unit = {
  12.     implicit val z:Int = 100
  13.     println(add(10, 20))
  14.     add2(10)(z)
  15.     add3()(z)
  16.   }
  20.   def add(x:Int,y:Int)(implicit z:Int) = x+y+z
  21.   def add2(x:Int)(implicit z:Int) = x+z
  22.   def add3()(implicit z:Int) = z*z
  23. }

作用域外的隐式参数

  1. package tcode.chapter10
  3. object $02_ImplicitParam {
  5.   def main(args: Array[String]): Unit = {
  6.     //implicit val z:Int = 100
  7.     // 相同的，如果是importclass需要new对象
  8.     val implictObject = new implictObject2
  9.     import implictObject.z
  10.     println(add(10, 20))
  11.     add2(10)(z)
  12.     add3()(z)
  13.   }
  15.   def add(x:Int,y:Int)(implicit z:Int) = x+y+z
  16.   def add2(x:Int)(implicit z:Int) = x+z
  17.   def add3()(implicit z:Int) = z*z
  18. }

隐式转换（内部类）类

  1. package tcode.chapter10
  3. import java.io.File
  4. import scala.io.Source
  8. object $03_ImplicitClass {
  10.   implicit class RichFile(file:File){
  11.     def getLines():Iterator[String] = {
  12.       Source.fromFile(file,"utf-8").getLines()
  13.     }
  14.   }
  16.   /**
  17.     * 隐式类: 将一个内部类转换为隐式类
  18.     *   语法: implicit class 类名(属性名:待转换类型){...}
  19.             参数只能是一个，
  20.             而且只能有一个构造器
  21.     * 隐式类必须放在object/class中,不能置于最顶层
  22.     */
  23.   def main(args: Array[String]): Unit = {
  25.     val file = new File("d:/data.txt")
  27.     file.getLines().foreach(println(_))
  28.   }
  30. /*  implicit def file2RichFile(file:File):RichFile ={
  31.     new RichFile(file)
  32.   }*/
  33. }