scala高級內容(一) Case Class

一. 操作符

1. 自定義操作符

2. 操作付默認左結合調用.除了以:結尾的操作符是右結合調用

   object OperaterTest extends App{
     val a: myInt = new myInt(1)
     val b: myInt = new myInt(2)
     val c: myInt = new myInt(3)
   
     println(a +++ b)
     println((c---:b---:a).value)   //：結尾的操作符右結合,相當於(a.---:(b)).---:(c) = 1-2-3
   
   }
   
   class myInt(val value:Int){
     def +++(a:myInt):Int = {    // 定義操作符 +++
       a.value + value           // 要使a.value能夠訪問，主構造器的字段要生命成val.使getter,setter方法為public
     }
   
     // 操作符默認左結合,除了以:結尾的操作符使o結合的右.比如::
     def ---:(a:myInt):myInt = {  
       new myInt(this.value - a.value) 
     }
   }
   

二.apply,update,ubapply去名調用

1. apply(param)方法
   （1）apply對象通常聲明在半生對象中,用來構造對象
   （2）cala把apply()方法的調用簡化成了(param)

2. update(param)方法
   update()方法的調用,簡化成了(param)=

   object Test extends App{
     val scores = new mutable.HashMap[String,Int]
     scores("Bob") = 100       // update
     println(scores("Bob"))    // apply
   }
   

3. unapply方法
   （1）當用未初始化的變量放在一個類()里,和等式右側的對象進行匹配時,則這些未初始化的變量調用該類的unapply方法進行初始化
   （2）unapply()方法返回的結果使Option[元祖]類型的,要么是None,要么是Some[T]

   object CaseClassTest extends App{
     val Name(first,scend,third) = "haha hehe lala";   // first,second,third必須是未聲明的變量
     println(first)
     println(scend)
     println(third)
   }
   
   object Name{
     def unapply(input:String) :Option[(String,String,String)] = {  //元祖：不同類型的值的集合
       if(input.indexOf(" ") == -1)
         None
       else
         Some(input.split(" ")(0),input.split(" ")(1),input.split(" ")(2))
     }
   }
   

4. unapplySeq方法
   （1）unapply用來提取固定個數的變量，來給未知變量賦值.若要提取出不定長度的變量，用unapplySeq方法
   （2）unapplySeq與unapply不能同事存在，否則模式匹配時，只會調用unapply進行匹配

   object CaseClassTest extends App{
     val Name(first,scend,third) = "haha hehe lala";   // first,second,third必須是未聲明的變量
     println(first)
     println(scend)
     println(third)
   
     val str = "asd sdf gh sdf"
     str match {
       case Name(a,b,c) => println("3 param:"+a+","+b+","+c)
       case Name(a,b,c,d) => println("4 param:"+a+","+b+","+c+","+d)   
     }
   }
   
   object Name{
   
     def unapplySeq(input:String):Option[Seq[String]] ={
       if(input.indexOf(" ") == -1)
         None
       else
         Some(input.split(" "))
     }
   }
   

三. Case Class

1. 什么事樣例類：經過scala編譯器優化后，被更好的用於模式匹配規則的類
   （1）Case class的每個參數默認以val(不變形式)存在，除非顯式的聲明為var
   （2）自動產生伴生對象，、且半生對象中自動產生appay方法來構建對象
   （3）半生對象自動產生unapply方法，提取主構造器的參數進行模式匹配
   （4）自動產生copy方法，來構建一個與現有值相同的新對象
   （5）class中自動產生hashcode，toString，equals方法

   object CaseClassTest extends App{
     val currency:Money = RMB(12.3,"yuan")
     //多態下，子類的模式匹配
     currency match {
       case Dollar(x:Double) => println("dollar:"+x)
       case RMB(x:Double,y:String) => println("rmb:"+x+y)  //rmb:12.3yuan
     }
   
     val currency2 = RMB(23.4,"yuan")
     println(currency2.copy(value=12.1))   //RMB(12.1,yuan)  =>自動產生的toString
   
   }
   
   abstract class Money
   case class Dollar(value:Double) extends Money
   case class RMB(value:Double,danwei:String) extends Money
   

2. 匹配循環嵌套的樣例類
   （1）循環嵌套的樣例類：一個case class的對象中，包含另一個case class的對象實例
   （2）因為對象存在循環嵌套，則需要使用遞歸處理對象，切該對象要有別名，用於遞歸處理。name @ pattern

   object CaseClassTest extends App{
     val bundle:Item = Bundle("Father's day special",20.0,     // 這個對象包含2個Item，1個是artice，另一個是包含兩個artice的Bundle
       Article("scala for impatient",39.3),
       Bundle("other lanugage",10.0,Article("thinking in java",79.5),Article("c++ progeamme",65.4)))
   
     def price(it:Item):Double= it match {
       case Article(_,price) => price
       case Bundle(_,disc,items @ _*) => items.map(price(_)).sum - disc
     }
   
     println(price(bundle))
   }
   
   abstract class Item
   case class Article(description:String,price:Double) extends Item
   case class Bundle(description:String,discount:Double,iterms:Item*) extends Item
   

3. case class的密封
   （1）當case class的超類使用關鍵字sealed修飾，則編譯器會校驗對該超類對象的模式匹配規則中，是否列出了全部可能的子case類
   （2）且該超類的子類只能出現在超類的文件中，形成封閉，而不能出現在其他文件中