1. def withPrintWriter(file: File)(op: PrintWriter => Unit) {  
2.     val writer = new PrintWriter(file)  
3.     try {  
4.          op(writer)  
5.     } finally {  
6.          writer.close()  
7.     }  
8. }  
9. val file = new File("date.txt")  
10. withPrintWriter(file) {  
11.     writer => writer.println(new java.util.Date)  
12. }  

3.由于这种使用非常不方便，每次使用控制结构时都需要传递一个匿名函数，而且定义非常奇怪。因此scala引入了换名参数，在传统的控制结构中，后面的一部分可以看做一个无参有一个返回值的函数。声明如下:op:()=>Boolean,那么使用时就必须为()=>experssion。而换名参数把声明时的()换成了空格:op: =>Boolean，那么使用时就可以仅仅写expersion，这样就更加像传统的控制结构。同时，更重要的是，如果声明成函数。那么，由于声明和使用的地方不一致，也就不能在调用时使用本地变量。而换名参数正好克服了这种情况，因为他相当于在使用的地方声明，也就可以使用本地变量

换名参数

loan pattern

在这种情况下，使用资源的函数不能控制资源，他只是声明需要一个资源，然后在产生资源的地方把资源借给他，使用之后，由残生资源的一方负责释放资源。因此资源从来没有赤裸裸地出现在程序中，保证了资源一定会得到释放。

[java]

1. def withPrintWriter(file: File, op: PrintWriter => Unit) {  
2.     val writer = new PrintWriter(file)  
3.     try {  
4.          op(writer)  
5.     } finally {  
6.          writer.close()  
7.     }  
8. }  

这儿的withPrintWrite把file资源借给op函数，op函数仅仅使用，没有管理资源的权限。

模式匹配和样例类

样例类

在类声明前面加上case关键字的叫做样例类

特性

1.每一个样例类都会有一个默认的apply方法

2.样例类中主构造器中的属性都会产生字段。

3.样例类添加了toString，hashcode和equal方法

4.样例类还实现了一个copy方法，用于产生一个新对象

    val other = op.copy(operator="-",left=v,rigth=v)

模式匹配

[java]

1. def simplifyTop(expr: Expr): Expr =   
2.     expr match {  
3.     case UnOp("",UnOp("",e)) => e // Double negation   
4.     case BinOp("+", e, Number(0)) => e // Adding zero   
5.     case BinOp("*", e, Number(1)) => e // Multiplying by one   
6.     case _ => expr  
7. }  

1.在这儿不仅仅有匹配还有变量的赋值，e就会在模式匹配的时候来得到变量的值

2.匹配还允许进行嵌套。

3._是通用匹配

能力

常量匹配

[java]

1. def describe(x: Any) =   
2. x match {  
3.     case 5 => "five"  
4.     case true => "truth"  
5.     case "hello" => "hi!"  
6.     case Nil => "the empty list"  
7.     case _ => "something else"  
8.          }  

变量匹配

[java]

1. expr match {  
2.     case 0 => "zero"  
3.     case somethingElse => "not zero: "+ somethingElse  
4. }  

注意：

1.scala仅允许每个变量在匹配中被赋值一次

构造器匹配

[java]

1. expr match {  
2.     case BinOp("+", e, Number(0)) => println("a deep match")  
3.     case _ =>  
4. }  

这儿的类必须是样例类。

集合匹配

数组匹配

[java]

1. arr match{  
2.    case Array(0) => "0"  
3.    case Array(x,y) => x+" "+y  
4.    case Array(0,_*) => "0..."  
5.    case _ => something else  
6. }  

列表匹配

[java]

1. lst match {  
2.    case 0 :: Nil => "0"  
3.    case x::y::Nil => x+" "+y  
4.    case 0::tail => "0..."  
5.    case _ => "something "  
6. }  

元组匹配

[java]

1. pair match{  
2.    case (0,_) => "0 ..."  
3.    case (y,0) => y + "0"  
4.    case _ => "neither is 0"  
5. }   

类型匹配

[java]

1. def generalSize(x: Any) = x match {  
2.     case s: String => s.length  
3.     case m: Map[_, _] => m.size  
4.     case _ => 1  
5. }  

注意：

1.使用类型匹配可以同时实现类型检测和类型转化，因此在scala中要使用模式匹配来

2.由于java的类型擦除，故不能精确匹配泛型的类型

模式守卫

[java]

1. // match only positive integers   
2. case n: Int if 0 < n => ...  
3. // match only strings starting with the letter ‘a’   
4. case s: String if s(0) == 'a' => ...  

密封类

[java]

1. sealed abstract class Expr  
2. case class Var(name: String) extends Expr  
3. case class Number(num: Double) extends Expr  
4. case class UnOp(operator: String, arg: Expr) extends Expr  
5. case class BinOp(operator: String,left: Expr, right: Expr) extends Expr  

密封类仅允许同文件的类检测它，因此不用担心在模式匹配的时候出现未匹配的问题

Option类

其他用处

变量定义

[java]

1. val exp = new BinOp("*", Number(5), Number(1))  
2. val BinOp(op, left, right) = exp  

注意这儿的类必须是样例类