scala学习之：隐式类与隐式对象

1、（1）上下文界定[T:M]中，T和M都是泛型类型，它要求在上下文界定的作用域中存在一个类型为M[T]的隐式值，
注意该隐式值是以一种不可见的方式被加入到该作用域中成为一个字段。
（2）通过上下文界定中的隐式参数同样可以丰富类的功能。
代码示例：
package com.cdel.second

class Pair_Implicits[T:Ordering](val first:T ,val second : T){
def bigger(implicit ordered : Ordering[T]) =
if(ordered.compare(first, second) > 0) first else second
}

class Pair_Implicitly[T:Ordering](val first:T , val second : T){
def bigger = if(implicitly[Ordering[T]].compare(first, second)>0)
first else second
}
class Pair_Implicitly_Orderd[T:Ordering](val first:T,val second :T){
def bigger = {
import Ordered._
if(first>second) first else second
}
}
object Context_Bounds_Internals {
def main(args: Array[String]): Unit = {
println(new Pair_Implicits(4,9).bigger)
println(new Pair_Implicitly(4,9).bigger)
println(new Pair_Implicitly_Orderd(4,9).bigger)
}
}

2、所谓隐式类，就是用 implicit 标识符修饰的类。通过隐式类也可以丰富一个类的功能。和隐式转换类似
package com.cdel.second

import scala.io.Source
import java.io.File
object Context_Helper{
implicit class FileEnhancer(file: File){
def read = Source.fromFile(file.getPath).mkString
}
implicit class Op(x:Int){
def add(second:Int) = x + second
}
}
object Implicit_Class {
def main(args: Array[String]): Unit = {
import Context_Helper._
println(1.add(3))
println(new File("F:\\test.js").read)
}
}

3 、所谓隐式对象，就是在object关键字前用 implicit 标识符修饰的对象。通过隐式对象也可以丰富一个类的功能。
package com.cdel.second

abstract class Template[A]{

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

}

abstract class SubTemplate[A] extends Template[A]{

def unit:A

}

object Implicit_Object {

def main(args: Array[String]){

implicit object StringAdd extends SubTemplate[String]{

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

def unit:String = ""

}

implicit object IntAdd extends SubTemplate[Int]{

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

def unit : Int = 0

}

//m 即为隐式对象

def sum[A](xs:List[A])(implicit m:SubTemplate[A]):A = {

if(xs.isEmpty) m.unit

else m.add(xs.head,sum(xs.tail))

}

println(sum(List(1,2,3)))

println(sum(List("u","f","o")))

}

}
4、隐式转换内幕及最佳实践
代码示例：

import java.io.File

import scala.io.Source

class RichFile(val file: File) {

def read = Source.fromFile(file.getPath).mkString

}

class ImplicitFile(path:String) extends File(path)

object ImplicitFile {

implicit def file2RichFile(file: File) = new RichFile(file)

}

object HideType {

def main(args: Array[String]) {

println(new ImplicitFile("f:\\test.js").read)

}

}
隐式转换的操作规则：
1、要想成为隐式转换，必须标记implicit关键字，编译期是根据关键字来变异的。
2、implicit可以修饰参数、类、对象、函数
3、隐式转换在整个作用域链中，必须是单一的标识符。
4、单一调用规则。
以上内容是从王家林老师DT大数据课程第62、63、64讲的学习笔记。

DT大数据微信公众账号：DT_Spark

王家林老师QQ:1740415547

王家林老师微信号：18610086859

百度云盘地址：http://pan.baidu.com/s/1o6wxJdS

优酷播放地址：http://v.youku.com/v_show/id_XMTI4OTY0NDc2OA==.html

51cto的播放地址：http://edu.51cto.com/lesson/id-69500.html