一. 操作符
自定义操作符
-
操作付默认左结合调用.除了以:结尾的操作符是右结合调用
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)=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）且该超类的子类只能出现在超类的文件中，形成封闭，而不能出现在其他文件中