scala之-隐式转换 and implicit关键字修饰类、方法、变量

scala之-隐式转换 and implicit关键字

implicit 在scala中属于关键字，可以修饰变量、方法函数、类

implicit 变量 \ 隐士值、默认给该类型的变量加上缺省值，方法调用时，不需要传入该参数，默认就给你用缺省值进行填充了

Implicit 方法\ 主要是用来进行类型转换，也可以对类的功能进行扩展

Implicit 类

1 隐式转换函数

scala是一门强类型的面向对象的语言，Any分为值类型(AnyVal)、引用类型(AnyRef)。

AnyVal:Byte\Short\Int\Long\Float\Double\Char\Boolean\Unit\StringOps

AnyRef:ScalaColletions\JavaCollections\otherUserDefinedClasses

// 默认情况下的隐士转换
Char => Int
Int => Long\Float\Double
Byte => Short => Int => Long 都是隐士转换

Implicit def 都是在默认情况下会自动执行的，与函数名无关、只与函数参数的类型、返回值类型有关

//
val i:Int = 3.0 //这是编译不通过的

class A{
  
 def main(args:Array[String]){
  //如果在class中声明implicit def，那么就可以进行隐式强转 
 implicit def DoubleToInt(old:Double){
    	val i = old.toInt
      i
  }
  val i:Int = 3.0 //此时是可行的
 }
}

2 implicit方法

implicit方法可以拓展当前类的功能，与动态混入是类似的，与classes之间的依赖是无关的。

package com.shufang.two

//只代表MySQL的数据库
class DB_MySQL {
  def select() {
    println("select")
  }
}

//代表其他数据库
class OtherDB {
  def insert() {
    println("insert")
  }

  def delete() {
    println("delete")
  }
}

object testImplicit {
  def main(args: Array[String]): Unit = {
    //声明implicit函数
    implicit def auto(mysql: DB_MySQL): OtherDB = {
      new OtherDB()
    }

    val mysql = new DB_MySQL()

    mysql.select()

    //现在mysql对象还可以使用其他数据库实例的方法
    mysql.insert()
    mysql.delete()


    println("*" * 40)


    //声明隐士值，相当于在作用域内的系统变量，如果函数的参数是一个隐士值，那么它会去作用域下寻找对应类型的隐士值进行填充，所有say在调用的时候不需要传入参数，因为程序默认就给填充了一个缺省值
    implicit val name:String = "JackMan"

    def say(implicit b:String): Unit ={
      println(s"$b - hello")
    }

    say //JackMan - hello
  }
}

3 implicit类

scala 2.10的时候引入，也可以拓展类的功能

使用特点：

1、 implicit类相同作用域下不能有相同名字的标识符

2、 implicit类必须在"伴生对象"、“类”、"包对象下"声明

3、implicit类不能是样例类case class

4、 implicit类不能是最高级别的类，不能在最外层

5、 implicit类必须要有带有一个参数的构造器

package com.shufang.implicit1


object ImplcitClassDemo {

  //隐士类必须有一个带有一个参数的构造器，因为会在初始化构造器中类型实例的时候被调用
  implicit class Bigo(name:Bigo1){
    def bigo(): Unit ={
      println("bigo")
    }
  }

  //在声明一个Bigo1实例时，因为在相同的作用域，那么会执行Bigo隐士类的单参数构造器的方法,并初始化构造器中的代码块
  class Bigo1{
    def say(): Unit ={
      println("bigo1")
    }
  }

  def main(args: Array[String]): Unit = {
    val bigo = new Bigo1()

    //自己类的方法
    bigo.say()
    //隐士类的方法
    bigo.bigo()
  }

}

4 隐式值、默认值、传值的优先级

传值 > 隐式值 > 默认值