隐式转换：当某个类没有具体的方法时，可以在该类的伴生对象或上下文中查找是否存在隐式转换，将其转换为可以调用该方法的类，通过代码简单的描述下

一：隐式转换

1、定义类Man

class Man(val name: String)

2、定义类SuperMan，并在类中定义一个方法

class SuperMan(val name: String) {

  def makeMiracles = println(this.name + " is super man!")

}

3、在main方法中实例化man类，并调用makeMiracles方法，这时编译报错，提示man中没有这样的方法

    val man = new Man("Scala")

    man.makeMiracles  // 编译报错，提示man中无这样的方法

4、这时候我们就可以通过隐式转换的方式将man转换为SuperMan，这时候就可以调用makeMiracles

object Man {

  //隐式转换

  implicit def manToSuperMan(man: Man) = new SuperMan(man.name)

}

完整代码：

class Man(val name: String)

class SuperMan(val name: String) {

  def makeMiracles = println(this.name + " is super man!")

}

object Man {

  //隐式转换

  implicit def manToSuperMan(man: Man) = new SuperMan(man.name)

}

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

    val man = new Man("Scala")

    man.makeMiracles

}

二：隐式参数

简单看下代码：

def talk(name: String)(implicit content: String) {

    println(name + ":" + content)

  }

这里的content就是定义为隐式参数，在调用的时候如果定义了隐式变量，则可以不传content参数

implicit val content = "Money"

talk("Spark")  //如果上下文没有定义隐式变量，则需传两个参数，也可以传两个参数进行覆写隐式值

talk("Spark")("Scala") //Scala会覆盖Money

三：隐式类

  //隐式类

  implicit class sum(x: Int) {

    def add(y: Int) = x + y

  }

 //隐式类

println(3.add(2))  //本身3是没有add这样的方法，通过隐式类转换，就可以实现这样的功能，主要是看上下文中是否有参数为Int类型的隐式转换操作

四：隐式对象

示例代码：

abstract class Template[T] {

  def add(x: T, y: T): T

  def unit: T

}

//隐式对象

object ScalaImplicitObject {

  implicit object StringAdd extends Template[String] {

    override def add(x: String, y: String) = x.concat(y)

    override def unit: String = ""

  }

  implicit object IntAdd extends Template[Int] {

    override def add(x: Int, y: Int) = x + y

    override def unit: Int = 0

  }

}

定义sum方法

  def sum[T](list: List[T])(implicit t: Template[T]): T = {

    if (list.isEmpty) t.unit

    else t.add(list.head, sum(list.tail)) //递归调用sum

  }

在main方法中调用

import com.dt.scala.ScalaImplicitObject._  //导入隐式转换

println(sum(List(1 to 100: _*)))

println(sum(List("Spark", "-", "Scala")))