scala 系列之 17scala 隐式转换

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
<console>: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 = 1

predef这个类就是预定义的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))
  }
}