隐式转换

精度小的类型可以自动转换为精度大的类型,这个转换过程无需开发人员参与,由编译器自动完成,这个转换操作我们称之为隐式转换。

  • 如果程序编译出错,编译器会尝试在整个的作用域中查找能够让程序编译通过的方式
  • 如果找到,那么编译器会尝试二次编译,让之前编译出现错误的代码经过转换后能够编译通过。
  • 这个转换过程看不见,但是存在,就称之为隐式转换,所谓的隐式转换,其实就是类型的转换

隐式函数

object ScalaImplicit {
    def main(args: Array[String]): Unit = {
        implicit def transform( d : Double ): Int = {
            d.toInt
        }
        var d : Double = 2.0
        val i : Int = d
        println(i)
    }
}

隐式函数实现程序功能的扩展

符合OCP

    def main(args: Array[String]): Unit = {

        // 使用implicit声明的函数为隐式函数。
        implicit def thransform( user:User ): UserExt = {
            new UserExt()
        }

        val user = getUser()
        user.insertUser()
        user.updateUser()

    }
    class UserExt {
        def updateUser(): Unit = {
            println("update user...")
        }
    }
    class User {
        def insertUser(): Unit = {
            println("insert user...")
        }
    }
    def getUser() = {
        new User()
    }

隐式参数

def reg( implicit password : String = "000000" ): Unit = {
    println("默认密码:" + password)
}

隐式变量

  • 隐式参数不用传递,这个传递的过程由编译器完成
  • 在同一个作用域中,如果相同的转换规则的多个数据,会发生错误
implicit val password : String = "111111"
reg ==> 默认密码:111111

隐式类

在Scala2.10后提供了隐式类,可以使用implicit声明类,隐式类非常强大,同样可以扩展类的功能,在集合的数据处理中,隐式类发挥了重要的作用。

  • 其所带的构造参数有且只能有一个
  • 隐式类必须被定义在“类”或“伴生对象”或“包对象”里,即隐式类不能是顶级的。
def main(args: Array[String]): Unit = {
 	val user = new User()
    user.insertUser()
    user.updateUser()
}
implicit class UserExt(user:User) {
    def updateUser(): Unit = {
        println("update user...")
    }
}
class User {
    def insertUser(): Unit = {
        println("insert user...")
    }

隐式机制

  1. 当前代码作用域

    implicit class UserExt(user:User) {
        def updateUser(): Unit = {
            println("update user...")
        }
    }
    
  2. 父类或伴生对象

    class Parent {
        implicit class UserExt(user:User) {
            def updateUser(): Unit = {
                println("update user...")
            }
        }
    }
    object Parent {
        implicit class UserExt(user:User) {
            def updateUser(): Unit = {
                println("update user...")
            }
        }
    }
    
  3. 特征或伴生对象

    trait MyTrait {
        implicit class UserExt(user:User) {
            def updateUser(): Unit = {
                println("update user...")
            }
        }
    }
    object MyTrait {
        implicit class UserExt(user:User) {
            def updateUser(): Unit = {
                println("update user...")
            }
        }
    
  4. 在其他地方声明(包对象)

    package object chapter {
        implicit class UserExt(user:User) {
            def updateUser(): Unit = {
                println("update user...")
            }
        }
    }
    
  5. 直接导入

    import com.atguigu.bigdata.scala.test.TestTransform._
    
内容来源于网络如有侵权请私信删除

文章来源: 博客园

原文链接: https://www.cnblogs.com/POCOPOCOPOCO/p/16828558.html

你还没有登录,请先登录注册
  • 还没有人评论,欢迎说说您的想法!