1.模式匹配比java中的switch case强大很多，除了值，类型，集合等进行匹配，最常见的Case class进行匹配，Master.scala有大量的模式匹配。

Case "_"表示不满足上面的所有情况的体验，举个例子：

def bigdata(data: String){

data match{

case "Spack"=>println("WOW!!!")

case "Hadoop"=>println("OK")

case _=>println("sorry")

}

}

bigdata("Spack")    //Wow!!!

可以在case里面加入条件判断

def bigData(data:String)

{

data match{

case "Spark"=>println("Wow!!")

case "hadoop"=> println("ok")

case _ if data == "Flink" =>println("Flink")

case _=>println("other")

}

}

bigdata("Flink")  //Flink

对类型进行匹配

def exception(e: Exception){

e match{

casefileException:FileNotFoundException =>println("File not fount : " +fileException)

case _:Exception=>println("Exception" ,e) }

}

exception(new FileNotFoundException("oop!!!"))    //> File notfount : java.io.FileNotFoundException: oop!!!

对集合进行匹配

def data (array:Array[String])

{   arraymatch{

case Array("Scala")=>println("Scala")

caseArray(spark,hadoop,flink)=>println(spark +" : " +hadoop +" : " +flink +" : ")

case Array("Spark",_*)=>println("Spark...")

case _=>println("Unkown")

}

}                                                //> data: (array: Array[String])Unit

data(Array("Spark"))                              //> Spark...

data(Array("Scala"))                              //> Scala

data(Array("Scala","Spark","kafaka"))             //> Scala : Spark : kafaka :

对class进行匹配

scala> case class Person(name: String)

defined class Person

case classPerson(name: String)

Person("Spark")                                   // res0: worksheetest.Person = Person(Spark)

1：case class 相对于java中的bean，val 只有个get

2：实例自动调用伴生对象

class Person

case classWorker(name: String,salary: Double) extends Person

case classStudent(name: String,score: Double) extends Person

def sayHi(person:Person)

{

personmatch{

case Student(name,score)=>println("I am Student :"+name +","+score)

case Worker(name,salary)=>println("I am Worker :"+name +","+salary)

case _ =>println("Unknown")

}

}                                                 //> sayHi: (person: worksheetest.Person)Unit

sayHi(Worker("Worker",6.5))                       //> I am Worker :Worker,6.5

sayHi(Student("Student",6.5))                     //> I am Student :Student,6.5

DeployMessages源码中：

caseclassExecutorStateChanged(

appId:String,

execId:Int,

state:ExecutorState,

message:Option[String],

exitStatus:Option[Int])

extends DeployMessage

case class 使用时会生成很多对象

case object 本身就是一个实例，全局唯一

scala 的类型参数（重磅的东西）最好的难点，太有用了，在所有的spark源码中到处都是

例：RDD[T: ClassTag]

泛型，参数本身是有类型，scala的泛型，

泛型类和泛型函数

class Person[T](valcontent:T)

{

def getContent(id: T) = id+ " _ "+ content

}

val p = newPerson[String]("Spark")               //> p  :worksheetest.Person[String] = worksheetest$Person@50134894

p.getContent("Scala")                             //> res0: String = Scala _ Spark

泛型前面有+和-

* scala> def mkArray[T : ClassTag](elems: T*) =Array[T](elems: _*)
* mkArray: [T](elems: T*)(implicit evidence$1:scala.reflect.ClassTag[T])Array[T]
*
* scala> mkArray(42, 13)
* res0: Array[Int] = Array(42, 13)
*
* scala> mkArray("Japan","Brazil","Germany")
* res1: Array[String] = Array(Japan, Brazil, Germany)
* }}}

协变：如果S是T的子类型，并且List[S]也是List[T]的子类型,那么成为协变 class Person[+T] //强制定义为协变类型

C[+T]：如果A是B的子类，那么C[A]是C[B]的子类。逆变范围小
C[-T]：如果A是B的子类，那么C[B]是C[A]的子类。协变 范围大
C[T]：无论A和B是什么关系，C[A]和C[B]没有从属关系。

注：阅读Spark源码 RDD、HadoopRDD、SparkContext、Master、Worker的源码，并分析里面使用的所有的模式匹配和类型参数的内容。

总结：

T <% Writable: ClassTag
T可以隐身转换为Writable类型
ClassTag在上下文中注入隐式值

对于Manifest Context Bounds
[T : Manifest] 进化为ClassTag了，T:ClassTag  运行时传递完整的类型上下文信息

Seq[Dependency[_]] 相当于Seq[Dependency[T]]

另外有段重要注释：

{{{
* scala> def mkArray[T : ClassTag](elems: T*) = Array[T](elems: _*)
* mkArray: [T](elems: T*)(implicit evidence$1: scala.reflect.ClassTag[T])Array[T]
*
* scala> mkArray(42, 13)
* res0: Array[Int] = Array(42, 13)
*
* scala> mkArray("Japan","Brazil","Germany")
* res1: Array[String] = Array(Japan, Brazil, Germany)
* }}}
*

表明了ClassTag 的隐式转换机制。