八、隐式转换和隐式参数

た入场券 2024-04-17 06:23 73阅读 0赞

**目录**

一、隐式转换

1、隐式函数入门

2、隐式转换的注意事项和细节

3、隐式转换丰富类库功能

二、隐式值

三、隐式类

四、隐式的转换时机

五、隐式解析机制

六、隐式转换的前提

--------------------

# 一、隐式转换 #

## 1、隐式函数入门 ##

**（1）隐式函数基本介绍**

隐式转换函数是以implicit关键字声明的带有**单个参数**的函数。这种函数将会**自动应用**，将**值从一种类型转换为另一种类型**

**（2）隐式函数快速入门**

使用隐式函数可以优雅的解决数据类型转换

object ImplicitAbout {
      //  底层会生成f1$1
      //  将double类型转换成Int
      //  隐式函数应当在作用于才能生效
      implicit def f1(d: Double): Int = {
        d.toInt
      }
    }
    // 隐式函数应当在作用于才能生效，使用隐式转换时需要导入
    import  ImplicitAbout._
    object ImplicitTest {
      def main(args: Array[String]): Unit = {
        val d :Int = 15.6598712346564812//下划线表示使用了隐式转换
        println(d)
      }
    }

## **2、隐式转换的注意事项和细节** ##

*  隐式转换函数的**函数名可以是任意的**，隐式转换**与函数名称无关**，**只与函数签名（函数参数类型和返回值类型）有关。**
 *  隐式函数**可以有多个(即：隐式函数列表)**，但是**需要保证在当前环境下，只有一个隐式函数能被识别，**在当前环境中，***不能存在满足条件的多个隐式函数***

//在当前环境中，不能存在满足条件的多个隐式函数
    implicit def a(d: Double) = d.toInt
    implicit def b(d: Double) = d.toInt 
    val i1: Int = 3.5 //（X）在转换时，识别出有两个方法可以被使用，就不确定调用哪一个，所以出错
    println(i1)

## 3、隐式转换丰富类库功能 ##

**（1）基本介绍**

如果需要为一个类增加一个方法，可以通过隐式转换来实现。（动态增加功能）比如想为MySQL类增加一个delete方法

**（2）解决方案**

在当前程序中，如果想要给MySQL类增加功能是非常简单的，但是在实际项目中，如果想要增加新的功能就会需要改变源代码，这是很难接受的。而且违背了软件开发的OCP开发原则 (闭合原则 open close priceple)，***在这种情况下，可以通过隐式转换函数给类动态添加功能。***

object ImplicitTest {
      implicit def addDelete(mysql:MySQL): DB = {
        new DB //
      }
      def main(args: Array[String]): Unit = {
        val mysql = new MySQL
        mysql.insert()
    //    编译器工作，addDelete$1(MySQL).delete()
        mysql.delete()
        mysql.update()
      }
    }
    class MySQL{
      def insert(): Unit = {
        println("insert")
      }
    }
    class DB {
      def delete(): Unit = {
        println("delete")
      }
      def update(): Unit = {
        println("delete")
      }
    }

# 二、隐式值 #

**1、基本介绍**

**隐式值也叫隐式变量，**将某个形参变量标记为implicit，所以**编译器会在方法省略隐式参数的情况下去搜索作用域内的隐式值作为缺省参数**

object ImplicitTest {
      implicit val str1: String = "jack"
      def main(args: Array[String]): Unit = {
        hello
        testMultiParam(1,2)
      }
      def hello(implicit name: String): Unit = {
        println(name + " hello")
      }
      def testMultiParam(id:Int,age:Int)(implicit name: String): Unit = {
        println(s"name = $name , id = $id, age = $age")
      }
    }

# 三、隐式类 #

**1、基本介绍**

**在scala2.10后提供了隐式类**，可以使用**implicit**声明类，隐式类的非常强大，同样可以扩展类的功能，**比前面使用隐式转换丰富类库功能更加的方便，**在集合中隐式类会发挥重要的作用。

**（1）隐式类使用有如下几个特点：**

*  其所带的构造参数有且只能有一个
 *  隐式类必须被定义在“类”或“伴生对象”或“包对象”里，**即隐式类不能是 顶级的(top-level objects**)。
 *  隐式类**不能是case class**（case class在后续介绍 **样例类**）
 *  作用域内不能有与之相同名称的标识符

**（2）实例**

object ImplicitTest {
      def main(args: Array[String]): Unit = {
        //DB会对应生成隐式类,在创建mysql实例的时候发生隐式转换
        //在该隐式类的作用域范围创建 MySQL 实例时，该隐式类就会生效,由编译器完成
        implicit class DB(val m: MySQL) {
          def addSuffix(): String = {
            println("addSuffix scala")
            m + " scala"
          }
        }
        val mysql = new MySQL
        mysql.sayOk()
        //mysql1.addSuffix() ==> DB1$1(mysql1).addSuffix()
        //DB1$1(mysql1)返回的类型是 ImplicitClass$DB1$2
        //    println(mysql.addSuffix())
        val resStr = mysql.addSuffix()
        println(resStr)
      }
    }
    class MySQL {
      def sayOk(): Unit = {
        println("sayOk")
      }
    }

# 四、隐式的转换时机 #

*  当方法中的参数的类型与目标类型不一致时，或者是赋值时

object ImplicitTest {
      def main(args: Array[String]): Unit = {
        test(10.1)
      }
       def test(n:Int):Unit={
        println("ok")
      }
    //  隐式转换
      implicit def f1(d: Double): Int = {
        d.toInt
      }
    }

*  当对象调用所在类中不存在的方法或成员时，编译器会自动将对象进行隐式转换（根据类型）

# 五、隐式解析机制 #

即编译器是如何查找到缺失信息的，解析具有以下两种规则：

1、首先会在当前代码作用域下查找隐式实体（隐式方法、隐式类、隐式对象）。(一般是这种情况)

2、如果第一条规则查找隐式实体失败，会继续在隐式参数的类型的作用域里查找。类型的作用域是指与该类型相关联的全部伴生模块，一个隐式实体的类型T它的查找范围如下(这种情况范围广且复杂在使用时，应当尽量避免出现)：

*  如果T被定义为T with A with B with C,那么A,B,C都是T的部分，在T的隐式解析过程中，它们的伴生对象都会被搜索。
 *  如果T是参数化类型，那么类型参数和与类型参数相关联的部分都算作T的部分，比如List\[String\]的隐式搜索会搜索List的伴生对象和String的伴生对象。
 *  如果T是一个单例类型p.T，即T是属于某个p对象内，那么这个p对象也会被搜索。
 *  如果T是个类型注入S\#T，那么S和T都会被搜索。

# 六、隐式转换的前提 #

在进行隐式转换时，需要遵守**两个基本的前提**：

*  不能存在二义性
 *  隐式操作不能嵌套使用 // \[举例：\]如:隐式转换函数

object ImplicitTest {
      def main(args: Array[String]): Unit = {
        val  i :Int = 1.2
        println(i)
      }
      implicit def f1(d:Double):Int={
        d.toInt
    //    val num :Int = 5.6//error，不可以在隐式函数中调用隐式函数
      }
    }