Scala_(5)_隐式转换|并发编程

一、隐式转换

1.语法：

implicit def xxxToxxx()

代码1：
class Person(val name : String)

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

implicit def person2Engineer(p : Person): Engineer = {
    new Engineer(p.name, 10000)
}

def toCode(p : Person){
    p.code
}

toCode("scala")

代码运行结果：Coding.....

代码2:
class Level(level : Int)

def toWorker(name : String)(implicit level : Level){
    println(name + ":" + level)
}

implicit val level = new Level(8)
toWorker("Spark")

代码3：
object Context_Implicits{
    implicit val default:String = "Flink"
}

object Param{
    def print(content : String)(implicit language : String){
        println("language: " + content)
    }
}

object Implicit_Paramters{
    def main(args : Array[String]){
        param.print("Spark")("Scala")
    }
    
    import Context_Implicits._
    Param.print("Hadoop")
}

运行结果：
    Scala:Spark
    Flink:Hadoop

代码4:
import scala.io.Source

object  Context_Helper{
    implicit class FileInhancer(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(a.addSAP(2))
        println(new File(path).read)
    }
}

# ## 最佳实践：Scala中的隐式转换通常都是写在伴生对象中

二、并发编程

Scala中使用Actor实现并发编程

Java的并发是使用共享全局变量的加锁机制

代码5：
import scala.actors.Actor

class HiActor extends Actor{
    def act(){
        while(true){
            receice{
                case name : String => println(name)
            }
        }
    }
}

val actor = new HiActor
#启动线程
actor.start()

#接收和发送消息
actor  ! "Spark"

运行结果：Spark

代码6：
import scala.actors.Actor
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) => print(name + ":" + age)
                case Worker(name, age) => print(name + ":" + age)
            }
        }
    }
}

val b = new BasicActor
b.start

b ! Basic("Scala", 13)
b ! Worker("Spark",7)

运行结果：
    Scala：13
    Spark：7