Spark之Scala学习之路（五）

**Scala隐式
Scala并发编程**

隐式转化：

class Person(val name:String)
    class Engineer(val name:String,val salary:Double){
    def code = println("coding .......")
    }

    def toCode(p:Person){   //直接访问会报错，中找不到code方法
      p.code
    }

    implicit def person2Engineer(p:Person):Engineer={  //Person -> Engineer  implicit 一般带返回类型
    new Engineer(p.name,10000)
    }
    def toCode(p:Person){   //Person内没有code方法，寻找隐式转换函数（主要通过输入类型）
      p.code
    }
    toCode(new Person("Scala"))

class RicherFile(val file : File){
    def read = Source.fromFile(file.getPath()).mkString
}
class File_Implicits(path :String) extends File(path)
object File_Implicits{
    implicit  def file2RicherFile(file:File)  = new RicherFile(file)
}
object FileRead {
    def main(args: Array[String]): Unit = {
        println(new File_Implicits("E:/test/test.txt").read)
      }
    }

隐式参数
作用域的implicit val implicit var
隐式参数类型的伴生对象去找隐式值

class Level(val level :Int)           
//没有val以及其他变量申明，则是私有变量class Level(level :Int)   
def toWorker(name : String)(implicit level : Level){   //柯里化
    println(name+ ":" +level.level)
}
implicit val level= new Level(8)
toWorker("Spark")

object Context_Implicits{
    implicit val default : String = "Flink"
    }
    object Param{
    def print(content:String)(implicit language:String): Unit ={
    println(language+"："+content)
    }
    }
    object WordCount {
    def main(args: Array[String]): Unit = {
    Param.print("Spark")("Scala")
    import  Context_Implicits._
    Param.print("Hadoop")
      }
    }

隐式对象

abstract  class Template[T]{
  def add(x:T,y:T):T
}
abstract  class SubTemplate[T] extends Template[T]{
  def unit:T
}
object WordCount {
  def main(args: Array[String]): Unit = {
    implicit  object  StringAdd extends SubTemplate[String]{
      override def add(x: String, y: String): String = x concat y  //xy
      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
    }
    def sum[T](xs:List[T])(implicit m:SubTemplate[T]):T=
      if (xs.isEmpty) m.unit
      else m.add(xs.head,sum(xs.tail))  //tail是剩下的元素组成的List 这里是2,3,4,5

    println(sum(List(1,2,3,4,5)))
    println(sum(List("Scala","Hadoop","Flink")))}}

隐式类

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 WordCount {
  def main(args: Array[String]): Unit = {
    import Context_Helper._
    println(1.addSAP(2))    //默认到RichInt里找
    println(new File("a123.txt").read)
  }
}

并发编程：Actor
java 中:Thread共享全局变量的加锁机制

import scala.actors.Actor
class HiActor extends Actor{   //本身是接口，里面有act方法
def act(){
  while(true){
    receive{
      case name : String => println(name)  //模式匹配
    }
  }
}
}
val actor=new HiActor
actor.start()
actor ! "spark"   //存在个线程切换

case class Basic(name :String, age:Int)
case class Worker(name:String, age:Int)
class basicActor extends Actor{
  def act(){
    while(true){
      receive{
        case Basic(name,age) =>println("Basic Information: "+name+":"+age)
        case Worker(name,age) =>println("Worker Information: "+name+":"+age)
      }
    }
  }
}
val b=new basicActor
b.start
b ! Basic("Scala",13)   //! 异步  ！? 同步 一定要结果  ！！val future=a !!M (得到个结果)
b ! Worker("Hadoop",8)