第3章 控制结构和函数
Java 中把表达式和语句当成两个不同的东西，表达式有值，语句没有值，
只是控制结构。在 Scala 中，几乎所有语法结构都有值。
3.1 If else 表达式
scala> val x = 5 x: Int = 5 scala> val s = if( x > 0 ) 1 else -1 s: Int = 1
S 为什么会有值？
If 语句的返回类型取决于最后一条语句。语句后面的分号不是必须的。
Scala 没有三元运算符，不需要。
If 表达式会有一个返回值类型，如果 if 或者 else 返回的类型不一样，就
返回 Any 类型（所有类型的公共超类型）。
scala> val s1 = if( x > 0) "hello" else -1 s1: Any = hello scala> val s3 = if ( x < 0 ) "hello" s3: Any = ()
如果缺少一个判断，什么都没有返回，但是 Scala 认为任何表达式都会
有值，对于空值，使用 Unit 类，写做（）【叫做无有用占位符，相当于 java
中的 void】
scala> val s4 = if(x < 0 ) "hello" else () s4: Any = ()
注：行尾的位置不需要分号，只要能够从上下文判断出语句的终止即可。但是如果
在单行中写多个语句，则需要分号分割。在 Scala 中，{}快包含一系列表达
式，其结果也是一个表达式。块中最后一个表达式的值就是块的值。
3.2 while 表达式
Scala 提供和 Java 一样的 while 和 do 循环，与 If 语句不同，While 语句
本身没有值，即整个 While 语句的结果是 Unit 类型的()。
while (n > 0) { r = r * n n -= 1 println(r) } do{ r = r * n n -= 1 println(r) }while(n > 0)
注：scala 并没有提供 break 和 continue 语句来退出循环，如果需要 break，可以
通过几种方法来做 1、使用 Boolean 型的控制变量 2、使用嵌套函数，从函数中
return 3、使用 Breaks 对象的 break 方法。
//循环的终止 import scala.util.control.Breaks val looper = new Breaks() //括号可以省略 var count = 0 looper.breakable{ // . 可以替换成空格 while(count <= 100){ count += 1 println(count) if(count == 10){ looper.break() } }
//多重while循环的终止 val whileLooper1 = new Breaks val whileLooper2 = new Breaks whileLooper1.breakable{ while (true){ count += 1 if(count == 10){ whileLooper1.break() } whileLooper2.breakable{ while (true){ if(count == 20){ whileLooper2.break() } } } } }
3.3 for 表达式
Scala 也为 for 循环这一常见的控制结构提供了非常多的特性，这些 for
循环的特性被称为 for 推导式（for comprehension）或 for 表达式（for
expression）。
推导式一词起源于函数式编程。
像 变量名 <- 集合 这样的表达式也被称为生成器表达式，该表达式会
基于集合生成单独的数值。
//多重for循环 for(i <- 1 to 3; j <-1 to 3){ println(i + "----" + j) println() }
//输出10 9 8 7 ... 1 for(i <- Range(10, 0, -1)){ println(i) } //输出1~9 for(i <- 1 until 10){ println(i) }
保护式，也叫守卫，可以添加一个或者多个守卫，不需要 continue 语句
//实现1~10的输出，只输出偶数 for (i <- 1 to 10 if i % 2 == 0){ println(i) }
For 推导式可以引入变量
//在for循环中添加变量表达式 for(i <- 1 to 10; j = 10 - i; m = j * i){ println("j:" + j) println("m:" + m) }
需要返回值怎么办？
使用 yield 关键字便能在 for 表达式中生成新的集合。for-yield 表达式所
生成的集合类型将根据被遍历的集合类型推导而出。
scala> val forResult = for (i <- 1 to 10) yield i forResult: scala.collection.immutable.IndexedSeq[Int] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
尖叫提示：{}和()对于 for 表达式来说都可以。for 推导式有一个不成文的约定：当
for 推导式仅包含单一表达式时使用原括号，当其包含多个表达式时使用大括
号。值得注意的是，使用原括号时，早前版本的 Scala 要求表达式之间必须
使用分号。
//使用花括号作为for循环的条件包裹 for{ i <- 1 to 3 m = i * 2 } println(m) //需要使用具体的逻辑
Scala 随堂笔记
一、变量的声明 ** val：初始化后不能被再次赋值 ** var：初始化之后可以多次复制 ** if else：有返回值，如果多个逻辑控制代码块，返回不同的值，则返回为：Any ** 循环： ** while -- 返回值类型为Unit -> () -- break的用法 ** for -- 基本形式 -- 守卫 -- 表达式 -- 多个循环体放在同一个参数体内 -- 输出遍历元素到一个集合中并返回：yeild i -- {}花括号形式，用的不多
3.4 函数
Scala 提供了很多函数，如果 math 函数，Java 中通常通过静态方法来模
拟。函数定义如下：
def 函数名（参数名：类型…）[: 返回类型] = 函数体
比如：
def play(a1 : Int, a2 : Int) : String = {
(a1 + "," + a2) }
def play(a1 : Int, a2 : Int) = { //返回值可以省略
a1 + a2 }
def paly(a1 : Int, a2 : Int) = a1 + a2
def paly = 1;
//标准形式 def play1(a1: Int, a2: Int): String = { String.valueOf(a1 + a2) } println(play1(10, 20)) //省略返回值形式（返回的是循环中最后一行的值） def play2(a1: Int, a2: Int) = { a1 + a2 } println(play2(10, 10)) //省略花括号形式 def play3(a1: Int, a2: Int) = a1 + a2 println(play3(5, 5)) //返回Unit类型的函数 def play4(a1: String) : Unit = { println(a1) } //返回Unit类型的函数，但是没有显示指定返回类型。（当然也可以返回非Unit类型的值） def play5(a1: String) = { println(a1) } //返回类型有多种可能，此时也可省略Unit def play6(a1: String) = { if(a1.length >= 3) a1 + "hello" else 3 } //可选参数 def play7(a1: Int, a2: Int = 10) = { a1 + a2 } println(play7(1)) //变长参数 def play8(args: Int*) = { for(i <- args){ println(i) } } play8(1,2,3,4,5) //递归函数：在使用的时候必须要有明确的返回值类型 //递归实现阶乘 def factorial(n : Int) : Int = { if(n == 1) n else factorial(n - 1) * n } println(factorial(3))
注：1、Scala 可以通过=右边的表达式 推断出函数的返回类型。如果函数体需要
多个表达式，可以用代码块{}。
2、可以把 return 当做 函数版本的 break 语句。
3、递归函数一定要指定返回类型。
4、变长参数通过* 来指定，所有参数会转化为一个 seq 序列
5、_* 告诉编译器 Range 当做参数序列化处理。
6、Head 是获得首元素，tail 是获取剩下元素的序列。
3.5 过程
我们将不返回值得函数叫做过程，返回类型是 Unit，他是没有=号的。
1）定义过程示例1：（显示的返回值类型为Unit）
def shout1(content: String) : Unit = {
println(content)
}
2）定义过程示例2：（隐式的返回值类型是Unit）
def shout1(content: String) = {
println(content)
}
3）定义过程示例3：（没有 = 号）
def shout1(content: String) {
println(content)
}
3.6 匿名函数
//匿名函数 /* * 1、匿名函数右边的函数体应该使用 => 符号来指定 * 2、匿名函数的函数体，可以是一个包含多行代码的代码块 * 3、函数的类型，为参数个数的类型 */ val play10 = () => 0 println(play10) //<function0> 表示传参个数为0 println(play10()) //0 val play11 = (a1 : Int) => 0 println(play11) //<function1> 表示传参个数为1 val play12 = (a1 : Int, a2 : Int) => { a1 + a2 a2 - 10 + a1 } println(play12) //<function2> println(play12(10, 20)) //20
3.7 懒值
当 val 被声明为 lazy 时，他的初始化将被推迟，直到我们首次对此取
值。
懒值使用注意：
1) 用于初始化开销比较大的语句。
2) 可以解决循环依赖问题。
3) 是开发懒数据结构的基础。
1）lazy 示例：通过 lazy 关键字的使用与否，来观察执行过程
def play1(a1: Int) = { println("play1方法被执行," + "a1:" + a1) a1 } lazy val l1 = play1(10) val l2 = play1(20) println("l1变量定义完毕") println(l1) /* 结果： play1方法被执行,a1:20 lazy变量定义完毕 play1方法被执行,a1:10 10 */
3.8 异常
当碰到异常情况时，方法抛出一个异常，终止方法本身的执行，异常传
递到其调用者，调用者可以处理该异常，也可以升级到它的调用者。运行系
统会一直这样升级异常，直到有调用者能处理它。 如果一直没有处理，则终
止整个程序。
Scala 的异常的工作机制和 Java 一样，但是 Scala 没有“受检”异常，你
不需要声明说函数或者方法可能会抛出某种异常。受检异常在编译器被检
查，java 必须声明方法所会抛出的异常类型。
抛出异常：用 throw 关键字，抛出一个异常对象。所有异常都是
Throwable 的子类型。throw 表达式是有类型的，就是 Nothing，因为 Nothing
是所有类型的子类型，所以 throw 表达式可以用在需要类型的地方。
／／并不像 Java 代码那样，需要声明方法会抛出异常，这给程序员省去理论很多烦恼。 def divide(x: Int, y: Int): Int = { if (y == 0) throw new Exception("Divide by zero") else x / y }
捕捉异常：
在 Scala 里，借用了模式匹配的思想来做异常的匹配，因此，在 catch 的
代码里，是一系列 case 字句。
异常捕捉的机制与其他语言中一样，如果有异常发生，catch 字句是按次
序捕捉的。因此，在 catch 字句中，越具体的异常越要靠前，越普遍的异常越
靠后。 如果抛出的异常不在 catch 字句中，该异常则无法处理，会被升级到
调用者处。
异常捕获通常采用模式匹配的语法：
try { process(in) } catch { case ex: IOException => println(ex) } finally { in.close()}
finally 字句用于执行不管是正常处理还是有异常发生时都需要执行的步
骤，一般用于对象的清理工作。
注：1、Throw 的类型为 Nothing，存在 exception 的 if 语句类型返回类型。
object ExceptionSyllabus { def divider(x: Int, y: Int): Float = { if(y == 0) throw new Exception("0 不能作为除数") else x/y } def main(args: Array[String]): Unit = { try { println(divider(10, 0)) } catch { case ex:Exception => println("成功捕获异常" + ex.getMessage) // case ex:Throwable => println("成功捕获异常" + ex.getMessage) } finally {} } }