Scala隐式转换

隐式转换

隐式转换增强现有类型

import scala.io.Source //RichFile相当于File增强类,需要将被增强的类作为参数传入增强类构造器中 class RichFile(filePath :String){ def read():String = { Source.fromFile(filePath).mkString } } //implicit定义一个隐式转换函数把被增强类型转换成增强的类型 object MyPredef{ //File --> RichFile implicit val filePath2File = (filePath:String) => new RichFile(filePath) } object HelloImplicitConversions { def main(args: Array[String]): Unit = { val filePath = "c://cc//cc.txt" //导入隐式转换 import MyPredef._ //String类本身没有read(),隐式转换为RichFile类调用的read() filePath.read } }

隐式参数

object Param{ def printA(context:String)(implicit default:String) = println(context + default) } object MyPreder{ //定义隐式参数 implicit val default:String = "在吃饭" } object ImplictParameters { def main(args: Array[String]): Unit = { //隐式参数可以正常传值 Param.printA("天金")("在喝水") //隐式参数没有传值，编译器会在全局范围内搜索implicit String类型的隐式值传入 import MyPreder._ Param.printA("李赤") } }

隐式参数隐式转换

object ImplicitConversionswithImplicitParameters { def main(args: Array[String]): Unit = { // 柯里化的泛型方法everythingCompare // 第二个括号传入的是一个匿名函数,类型为T => Ordered[T] // 传入隐式参数,输入类型为T类型,返回类型为Ordered[T]类型 def everythingCompare[T](a:T, b:T)(implicit e:T => Ordered[T]):T = { //ordered(a) > b //if(e(a) > b) a else b if(a > b) a else b } println(everythingCompare(4, 3)) println(everythingCompare("Shangtj", "LiheChi")) } }

隐式类（少）

有时候进行代码重构，要增强他的某项功能同时又不想做太大的改动

import scala.io.Source object Context_helper{ implicit class FilePath2File(filePath:String){ def read:String = Source.fromFile(filePath).mkString } implicit class OpAdd(x:Int){ def add(y:Int):Int = x + y } } object ImplicitsClass { def main(args: Array[String]): Unit = { import Context_helper._ val fn = "d://myFile//ff.md" println(fn.read) println(1.add(2)) } }

隐式对象

abstract class Template[T]{ def add(x:T, y:T):T } abstract class SubTemplate[T] extends Template[T]{ def unit:T } object ImplicitsObject { implicit object StringAdd extends SubTemplate[String]{ override def add(x: String, y: String): String = x concat y override def unit: String = "" } implicit object IntAdd extends SubTemplate[Int]{ override def add(x: Int, y: Int): Int = x + y override def unit: Int = 0 } //im是隐式对象 def sum[T](list :List[T])(implicit im:SubTemplate[T]):T = { if(list.isEmpty) im.unit //list.tail除第一个元素外其他元素 else im.add(list.head, sum(list.tail)) } def main(args: Array[String]): Unit = { println(sum(List(1, 2, 3))) println(sum(List("A", "B", "C"))) } }

也可以用来做参数类型转换

implicit def object2SpecialPerson(obj : Object) : SpecialPerson = { obj match{ case a : Student => {val stu = obj.asInstanceOf[Student];new SpecialPerson(stu.name)} case b : Older =>{val old = obj.asInstanceOf[Older];new SpecialPerson(old.name)} case _ => Nil } }

上下文界定中的隐式参数

在每次上下文运行的实例对象中将具体的值注入到隐式参数中，而且注入的过程是自动的

//[T: Ordering]：说明存在一个隐式类型Ordering[T] class Pair_Implicits[T: Ordering](val a: T, val b: T){ //声明一个隐式类型对象传入函数 def bigger(implicit ordered: Ordering[T]) = { if (ordered.compare(a, b) > 0) a else b } } object ContextBoundsInternals { def main(args: Array[String]): Unit = { new Pair_Implicits(1, 2).bigger } }