隐式转换
import scala.io.Source
import java.io.File
class RichFile(val file:File){
def read = Source.fromFile(file.getPath()).mkString
}
object Context{
implicit def file2RichFile(file:File)= new RichFile(file) //File -> RichFile
}
object Hello_Implicit_Conversions {
//在伴生对象和作用域中找隐式转换
def main(args: Array[String]) {
import Context.file2RichFile
println(new File("test.txt").read)
}
}
隐式参数
object Context_Implicits{
implicit val default:String = "Java"
}
object Param{
//第二个参数为隐式值,作为默认参数,如果不传入,就寻找隐式值
//柯里化方式
def print(content:String)(implicit language:String){
println(language+":"+content)
}
}
object Implicit_Parameters {
def main(args: Array[String]) {
Param.print("Spark")("Scala") //Scala:Spark
import Context_Implicits._
Param.print("Hadoop") //Java:Hadoop
}
}
object Implicit_Conversions_with_Implicit_Parameters {
def main(args: Array[String]) {
//隐式参数下的隐式转换
//ordered为一个函数
def bigger[T](a: T, b: T)(implicit ordered: T => Ordered[T])
= if (a > b) a else b //等价于if (ordered(a)> b) a else b
println(bigger(4,3))
println(bigger(4.2,3))
println(bigger("Spark","Hadoop"))
}
}
上下文界定内幕中的隐式参数与隐式参数
class Pair_Implicits[T: Ordering](val first: T, val second: T){ //Ordering[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_Odereded[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]){
println(new Pair_Implicits(7, 9).bigger)
println(new Pair_Implicitly(7, 9).bigger)
println(new Pair_Implicitly_Odereded(7, 9).bigger)
}
}
隐式类
import java.io.File
import scala.io.Source
object Context_Helper{
implicit class FileEnhancer(file : File){
def read = Source.fromFile(file.getPath).mkString
}
implicit class Op(x:Int){
def addSAP(second: Int) = x + second
}
}
object Implicits_Class {
def main(args: Array[String]){
import Context_Helper._
println(1.addSAP(2))
println(new File("test.txt").read)
}
}
隐式对象
abstract class Template[T] {
def add(x: T, y: T): T
}
abstract class SubTemplate[T] extends Template[T] {
def unit: T
}
object Implicits_Object {
def main(args: Array[String]) {
implicit object StringAdd extends SubTemplate[String] {
override def add(x: String, y: String) = x concat y
override def unit: String = ""
}
implicit object IntAdd extends SubTemplate[Int] {
override def add(x: Int, y: Int) = x + y
override def unit: Int = 0
}
def sum[T](xs: List[T])(implicit m: SubTemplate[T]): T =
if (xs.isEmpty) m.unit
else m.add(xs.head, sum(xs.tail))
println(sum(List(1, 2, 3, 4, 5)))
println(sum(List("Scala", "Spark", "Kafka")))
}
}