这个关键词，在Scala的开发中是做隐式转换时用到的
隐式转换在Scala开发中的作用是当操作的实体，无法满足操作条件时，如果拥有隐式转换的条件，那么会自动触发，然后使得操作的实体拥有符合操作条件的特性，可以看成是对实体的一种增强。
隐式转换的应用场景分为两种：
- 1.隐式转换函数
- 2.隐式转换值
不过使用隐式转换有一个很要命的事情，就是同一种类型的隐式转换最好在一个运行流程中只存在一个，这里说的同一种，指的是参数类型、返回值一样的隐式转换，而名字是用来在不同的运行流程中import的
首先给大家介绍的是隐式转换函数，话不多说给大家举个隐式转换函数例子，如下
package com.wy
class SpecialPeron(var name: String)
class Older(var name: String)
class Student(var name: String)
class Teach(var name: String)
object ImplicitDemo {
def buySpecialTickWindow(peron: SpecialPeron): Unit = {
if (peron != null) {
println(peron.name + "购买了一张特殊票！")
} else {
println("你不是特殊人群，不能在此买票！")
}
}
//隐式转换函数：作用是本来buySpecialTickWindow方法接收的是SpecialPeron类
//但是有了这个方法，就可以传入其他的类型，转换的方式在转换函数中写明就可以了
implicit def anytoSpecialPerson(any: Any): SpecialPeron = {
/**
* 这里用模式匹配，你也可以用if/else只是比较麻烦
*/
any match {
case any: Older => new SpecialPeron(any.asInstanceOf[Older].name)
case any: Student => new SpecialPeron(any.asInstanceOf[Student].name)
case _ => null
}
}
def main(args: Array[String]): Unit = {
val older = new Older("老人")
val student = new Student("学生")
val teacher = new Teach("讲师")
buySpecialTickWindow(older)
buySpecialTickWindow(student)
buySpecialTickWindow(teacher)
}
}
上面这个就是隐式转换的一种用途，总结一句话，隐式转换函数是用来增强程序的可执行性，来弥补程序运行时的一些可以用这类手段弥补的问题，当然想让它触发你的操作实体和操作的业务场景，一定要符合隐式转换的参数类型以及返回值
这个时候有人有小伙伴可能会迷惑，当隐式转换需求量很大的时候，咱们办，因为前面也说了，一个运行流程里一个类型的隐式转换方法只能有一个，如果有两个，运行的时候是会报错的，别急这个问题看我下面给大家准备的这个例子了
package com.wy
import java.io.File
import scala.io.Source
/*
这个注释的object 是想让大家看一下一般情况下我们如何用普通手段读取文件数据的，让大家看下面的东西的时候不迷糊
object ImplicitsTest {
def main(args: Array[String]): Unit = {
val file = new File("C:\\Users\\小象\\Desktop\\6月\\0618\\1.txt")
println(Source.fromFile(file).mkString)
//println(file.read)
}
}*/
//-------------------------------下面正题开始了，敲黑板了，注意----------------------------------------------
//这里自定义的RichFile相当于File的增强类 用主构造器来包含被他增强的类
class RichFile(val file: File) {
def read = {
Source.fromFile(file).mkString
}
}
//前面说了implicit是隐式转换的关键字 这里定义一个隐式转换函数把当前类型转换成增强后的类型
//这也是我前面说的一个运行流程中一个类型只有一个隐式转换的实行方法，在正式开发的时候这些隐式转换都是写在一个object里面的用的时候import调用就行
object Context {
//File类 --> RichFile自定义类
implicit def file2RichFile(file: File) = new RichFile(file)
}
//使用的时候如下
object Hello_Implicit_Conversions {
def main(args: Array[String]): Unit = {
//导入隐式转换
import Context.file2RichFile
//当然你也可以把隐式转换任然写在这里
//implicit def file2RichFile(file: File) = new RichFile(file)
//File类本身没有read方法 通过隐式转换完成
//这里的read方法是RichFile类中的方法 需要通过隐式转换File --> RichFile
println(new File("C:\\1.txt").read)
}
}
隐式转换方法的使用就是这样，下面我给大家介绍隐式转换值
这个隐式转换值比较简单它主要是两种使用场景，第一种是给方法的参数设定默认值，不过方法要进行柯里化
package com.wy
object ImplicitValue {
def main(args: Array[String]): Unit = {
println(myCurry3(1))
//正常调用
println(myCurry3(1)(3))
//当y没有传入参数的时候，默认为2
def myCurry3(x:Int)(implicit y:Int=2)=x+y
}
}
第二中用途是给一个类型一个默认值，达到当使用这个类型时不需要在去赋值或实例化，就可以直接使用
package com.wy.driver
object TTT {
def main(args: Array[String]): Unit = {
implicit val i:Int=6
println(i)
}
}
以上就是我和大家分享的东西，最后我要和大家说的是无论是隐式转换函数还是隐式转换值，他们本身还是一个方法和值是可以手动调用的，并不是说它们被implicit修饰最后就没有办法调用了
其次是implicit和object大家不要混淆，implicit之后虽然不手动调用时程序会自动调用import的或者是就在运行流程里的，但是它本质还是需要出现在object的main里面的，两个不是一个概念，人家object是掌管Scala程序入口的角色