21 隐式转换
作用：能够丰富现有类库的功能，对类的方法进行增强，常用作类型转换也就是把一个类型转赋予另一个类的功能；
隐式转换应用场景
隐式转换函数、隐式值、隐式参数、隐式对象（只能在静态对象中使用）；
21.1 隐式转换函数#
隐式转换函数 是指 以implicit关键字声明并带有单个参数的函数，这样的函数被自动应用。
// 声明隐式函数，用于将 int类型转成 String 类型
implicit val int2Stringfunc = (a:Int) => a.toString使用示例：
// 定义Int类型
scala> val a = 12345
a: Int = 12345
// Int类型没有 length 方法
scala> a.length
:13: error: value length is not a member of Int
a.length
^
// 定义隐式转换函数 (Int)=>String
scala> implicit def int2string(a:Int) = a.toString
warning: there was one feature warning; re-run with -feature for details
int2string: (a: Int)String
// 当执行时，看Int类型是否有length成员，如果有直接调用
// 如果没有，但当前环境是否有隐式函数，能将Int转成有该length成员的类型，如果有则调用
// 执行过程： Int --> String --> 调用String类型的length方法
scala> a.length
res2: Int = 5 scala内部自带了很多隐式转换函数和方法。如1 to 10其实是调用的1.to(10)这个方法
但是在Int类中并没有to这个方法
基本数据类型都有对应的 富包装（rich wrapper），可以隐式转换为相应的富类型，它具有额外的方法。
int 类型是如何隐式转换成 RichInt 类型的？
int 的to方法实际上是调用Predef里的intWrapper方法，最终调用的是RichInt里的to方法；
intWrapper就是以implicit关键字声明并带有单个参数的函数，intWrapper就是一个隐式转换方法；
用于scala 和 java 类型互转
scala> val a:Int = 1
a: Int = 1
// 将 scala 的 Int类型 赋给 java 的 Integer 类型
scala> val b:Integer = a
b: Integer = 1
// 将 java 的 Integer 类型 赋给 scala 的 Int类型
scala> val c:Int = b
c: Int = 1predef这个类就是预定义的predefine的简写
在shell中用:implicit -v来查看，默认有多少个隐式转换函数
在2.11.8中有69个隐式转换，scala升级比较快所以其它版本可能不同
隐式转换函数其实用到了装饰模式（增强）
核心思想：用组合实现嵌套逻辑，每层有自己的个性化动作。在不修改原有类的基础上，给原有类增加功能。
装饰模式对应的是门面模式（简化）
21.2 隐式参数和隐式值#
在调用含有隐式参数的函数时，编译器会自动寻找合适的隐式值当做隐式参数，而只有用implict标记过的值、对象、函数才能被找到。
def add(x:Int)(implicit y:Int = 10) = x + y // 参考 柯理化 隐式关键字例子
隐式参数注意：方法的参数如果有多个隐式参数的话，只需要使用一个implicit关键字，隐式参数列表必须放在方法的参数列表后面；
示例：
scala> def demo(a:Int)(implicit b:Int, c:Int) = a + b + c
demo: (a: Int)(implicit b: Int, implicit c: Int)Int
scala> implicit val b1:Int = 10
b1: Int = 10
// 一个隐式值作用在多个隐式参数上
scala> demo(5)
res5: Int = 25隐式函数作为隐式参数：
// 定义隐式函数
implicit val int2stringfunc = (a:Int) => a.toString
def sayLength(implicit str:String) = println(s"${str.length}")
sayLength(1234)21.3 隐式对象#
隐式对象只能在别的trait/类/对象内部定义。
package util
object MyPredef {
// 定义隐式值1
implicit val b1:Int = 10
// 定义隐式值2
implicit val b2:Int = 20
// 定义隐式对象（虽然是对象，但必须把它包起来，因为不能作为顶级对象）
implicit object HainiuObj{
def say() = println("say hello")
}
}
package day04
import util.MyPredef
object ImplictObjectDemo {
def main(args: Array[String]): Unit = {
// 先引入隐式对象，当前环境就有这个隐式对象了
import util.MyPredef.HainiuObj
// 通过implicitly 把 隐式对象变成显示的
val obj = implicitly[MyPredef.HainiuObj.type ]
obj.say()
}
}21.4 隐式转换的应用示例#
1）类型转换
object ImplicitDemo {
/**
* 定义了一个隐式转换的方法
*/
implicit def double2Int(d:Double) = {
println(s"double:${d} to int:${d.toInt} method")
d.toInt
}
/**
* 定义了一个隐式转换的函数
*/
implicit val double2IntF = (d:Double) => {
println(s"double:${d} to int:${d.toInt} function")
d.toInt
}
def m1(a:Int) = println(a)
def main(args: Array[String]): Unit = {
//当隐式转换方法和隐式转换函数同时存在，也就是入参，返回类型相同的情况下,则先找函数，因为scala是函数式编程，那函数就是老大
//如果函数和方法同时存在，就优先用函数
val d:Int = 6.6
m1(6.6)
}
}2）给代表文件地址的字符串增加一个可以读文件的功能
这是一个显示的调用并不是一个隐式的调用，这是我们平时开发过程中常用的方法
package day04
import scala.io.Source
class Reader(val path:String) {
// 读取文件得到文件内容返回
def read = Source.fromFile(path).mkString
}
object Reader{
def main(args: Array[String]): Unit = {
val path:String = "/tmp/scala/ip.txt"
val reader = new Reader(path)
println(reader.read)
}
}隐式转换函数的实现方法
首先在MyPredef写一个String的隐式转换函数；
package day04
import scala.io.Source
class Reader(val path:String) {
// 读取文件得到文件内容返回
def read = Source.fromFile(path).mkString
}
object Reader{
def main(args: Array[String]): Unit = {
val path:String = "/tmp/scala/ip.txt"
// val reader = new Reader(path)
// 通过隐式转换函数给字符串赋予读文件的功能（String => Reader）
import util.MyPredef.string2Reader
println(path.read)
}
}后面：会用到给字符串赋予删除hdfs目录的功能。
3）隐式转换参数 + 隐式转换对象 + 泛型 + Ordering
示例：
已知类 HainiuStudent，对 HainiuStudent 的两个对象作比较。
class HainiuStudent(val name:String, val age:Int){
override def toString: String = s"name:${name}, age:${age}"
}java的实现方法：定义外部比较器，用外部比较器去实现。（自行实现）
scala的实现方式：
1）创建隐式对象继承 Ordering[T] 类；
2）通过Ording[T] 类中提供的方法实现比较；
什么是Ordering[T]?
Ordering[T] 特质更像是rich版的Comparator接口，除了compare方法外，更丰富了比较操作（gt，lt，lteq，gteq，max，min 等）。
Ordering 伴生对象提供了 apply 方法。
trait Ordering[T] extends Comparator[T] with PartialOrdering[T] with Serializable{
def compare(x: T, y: T): Int
override def lteq(x: T, y: T): Boolean = compare(x, y) <= 0
override def gteq(x: T, y: T): Boolean = compare(x, y) >= 0
override def lt(x: T, y: T): Boolean = compare(x, y) < 0
override def gt(x: T, y: T): Boolean = compare(x, y) > 0
override def equiv(x: T, y: T): Boolean = compare(x, y) == 0
def max(x: T, y: T): T = if (gteq(x, y)) x else y
def min(x: T, y: T): T = if (lteq(x, y)) x else y
}
// 可以通过隐式对象获取Ordering对象
object Ordering extends LowPriorityOrderingImplicits{
def apply[T](implicit ord: Ordering[T]) = ord
}代码实现：
创建隐式对象继承 Ordering[T] 类
implicit object OrderStudent extends Ordering[HainiuStudent]{
override def compare(x: HainiuStudent, y: HainiuStudent): Int = x.age - y.age
}实现逻辑：
import scala.math.Ordering
class HainiuStudent(val name:String, val age:Int){
override def toString: String = s"name:${name}, age:${age}"
}
object OrderingDemo {
def choose(t1:HainiuStudent, t2:HainiuStudent): HainiuStudent = {
import test.t2.Mypredef.OrderStudent
// 方式1：调用 Ordering 的 apply[T] 方法
// def apply[T](implicit ord: Ordering[T]) = ord， 将隐式对象作为参数传入
if(Ordering[HainiuStudent].compare(t1,t2) > 0) t1 else t2
// gt 等效于 ompare(t1,t2) > 0
// if(ord.gt(t1,t2)) t1 else t2
// 方式2：通过implicitly 获取当前范围的隐式对象Ordering[HainiuStudent]
// val ord:Ordering[HainiuStudent] = implicitly[Ordering[HainiuStudent]]
// if(ord.gt(t1,t2)) t1 else t2
}
def main(args: Array[String]): Unit = {
val s1 = new HainiuStudent("niu1", 24)
val s2 = new HainiuStudent("niu2", 25)
println(OrderingDemo.choose(s1,s2))
}
}海汼部落原创文章，原文链接：(
http://hainiubl.com/topics/75752)