scala 隐式转换与隐式参数

隐式转换函数

指的是以implicit关键字声明的带有单个参数的函数,这种函数会自动引用,将值从一种类型转换为另一种类型.就是说如果类型不匹配时,会自动寻找一个隐式方法,把这个格式不匹配的事情解决掉.

定义变量b为Int类型,但是赋予值2.34 是不对的,但是由于找到了隐式方法,所以自己转换了

object _011Test {def main(args: Array[String]): Unit = {val b:Int=2.34println(b)//2}implicit  def double2Int(x:Double):Int=x.toInt
}

增强已有类的功能
就是说用到了一个类没有的功能时,系统会自动寻找有该功能的类,然后看是否有隐式方法可以把该类转换为有该功能的类.

import java.io.File
import scala.io.Sourceobject _011Test {def main(args: Array[String]): Unit = {import RichFile._//File类本身是没有read方法的,但是RichFile方法有read方法//当你强行要用File的read方法时,系统会自动查找别的类有没有read方法,然后再找是否有隐式方法可以把该类转为有read方法的那个类println(new File("D:\\tmp\\test.txt").read)}
}object RichFile {//隐式方法,用于把File类转为RichFile类implicit def file2RichFile(from: File): RichFile = new RichFile(from)
}//定义一个RichFile类,可以用于读取文件内容
class RichFile(val from: File) {def read: String = Source.fromFile(from.getPath).mkString
}

在编译过程中,当发现某一个类的对象调用了自己没有的方法,或者其他不正确的语法,一定会检查当前作用域的隐式函数,如果有此隐式函数,那么编译成功.

隐式参数

参数用implicit修饰的就是隐式参数. 隐式参数就是某些函数调用时没给传入参数,就拿隐式参数当做自己的参数.有点奇葩的设计

example1:
调用时少传参数,报错

调用时少传参数,不报错,因为用了隐式参数隐式参数多了,报错,不知道用哪一个

object _012Test {def main(args: Array[String]): Unit = {implicit val x = 6implicit val y=7val l = sum(1)println(l)//7}def sum(x: Int)(implicit y: Int): Int = x + y
}

再比如. 如下比较器是个隐式参数,可以不用传入

object _011Test {def main(args: Array[String]): Unit = {//调用的时候并没有传入隐式参数println(compare(3, 5)) //-1}//2 个参数列表,其中一个为隐式参数,就是调用的时候可以不提供def compare[T](x: T, y: T)(implicit ordered: Ordering[T]): Int = {ordered.compare(x, y)}
}

隐式类

目的,不想创建新对象,用一个参数就想创建一个新对象.
比如正常情况下

class xx(x:Int ){}

创建新对象是这样的

val p=new xx(5)

用来隐式类后,创建新对象是这样的

对象就创建完了. 啥也不需要了,直接给个构造函数的参数就完事了.
正常情况下

import scala.Console.println
import scala.annotation.tailrecobject _013Test {def main(args: Array[String]): Unit = {val p = new IntWithTimes(5)p.times(println("HI"))}
}object Helpers {class IntWithTimes(x: Int) {def times[A](f: => A): Unit = {@tailrecdef loop(current: Int): Unit =if (current > 0) {floop(current - 1)}loop(x)}}
}

隐式类情况,不用new直接调用. 或者说直接用参数就创建了一个新对象,这也太懒了

import scala.Console.println
import scala.annotation.tailrecobject _013Test {def main(args: Array[String]): Unit = {import Helpers._5 times(println("HI"))}
}object Helpers {implicit class IntWithTimes(x: Int) {def times[A](f: => A): Unit = {@tailrecdef loop(current: Int): Unit =if (current > 0) {floop(current - 1)}loop(x)}}
}

隐式引用

就是内置的一些包不需要import,系统会自己搞定.
比如,就是以下几个包,就是自动引用的,或者说隐式引用的

import java.lang._ // in JVM projects, or system namespace in .NET
import scala._     // everything in the scala package
import Predef._    // everything in the Predef object

ps:有个问题就是比如lang和scala都有String类的话,用哪个? 后导入的会覆盖先导入的,就是会用scala的,或者说lang包的String被隐藏了

总结

隐式方法类型自动转换
隐式参数懒得传参数
隐式类不想new对象
总结,就是想少写点代码,让代码看起来整齐点
隐式能看懂源码即可,自己还是少用