一. 操作符
- 自定义操作符
操作付默认左结合调用.除了以:结尾的操作符是右结合调用
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去名调用
- apply(param)方法
(1)apply对象通常声明在半生对象中,用来构造对象
(2)cala把apply()方法的调用简化成了(param) - update(param)方法
update()方法的调用,简化成了(param)=scala object Test extends App{ val scores = new mutable.HashMap[String,Int] scores("Bob") = 100 // update println(scores("Bob")) // apply }
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)) } }
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
什么事样例类:经过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
匹配循环嵌套的样例类
(1)循环嵌套的样例类:一个case class的对象中,包含另一个case class的对象实例
(2)因为对象存在循环嵌套,则需要使用递归处理对象,切该对象要有别名,用于递归处理。name @ patternobject 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
case class的密封
(1)当case class的超类使用关键字sealed修饰,则编译器会校验对该超类对象的模式匹配规则中,是否列出了全部可能的子case类
(2)且该超类的子类只能出现在超类的文件中,形成封闭,而不能出现在其他文件中