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）且该超类的子类只能出现在超类的文件中，形成封闭，而不能出现在其他文件中