流程控制
分支控制 if-else
让程序有选择的的执行，分支控制有三种：单分支、双分支、多分支。
单分支
package chapter04
import scala.io.StdIn
object TestIfElse {
def main(args: Array[String]): Unit = {
//需求：输入人的年龄，如果该同志的年龄小于 18 岁，则输出“童年”
println("input age:")
var age = StdIn.readShort()
//当条件表达式为 ture 时，就会执行{ }的代码
if (age < 18){
println("童年")
}
}
}双分支
//需求：输入年龄，如果年龄小于 18 岁，则输出“童年”。否则，输出“成年”。
println("input age:")
var age = StdIn.readShort()
if (age < 18){
println("童年")
}else{
println("成年")
}多分支
（1）需求：输入年龄，如果年龄小于 18 岁，则输出“童年”。如果年龄大于等于 18 且小于等于 30，则输出“中年”，否则，输出“老年”。
println("input age")
var age = StdIn.readInt()
if (age < 18){
println("童年")
}else if(age>=18 && age<30){
println("中年")
}else{
println("老年")
}（2）Scala 中 if else 表达式其实是有返回值的，具体返回值取决于满足条件的 代码体的最后一行内容。
println("input age")
var age = StdIn.readInt()
val res :String = if (age < 18){
"童年"
}else if(age>=18 && age<30){
"中年"
}else{
"老年"
}
println(res)
（3)Scala 中返回值类型不一致，取它们共同的祖先类型。
println("input age")
var age = StdIn.readInt()
val res:Any = if (age < 18){
"童年"
}else if(age>=18 && age<30){
"中年"
}else{
100
}
println(res)
println(res.getClass)
（4)Java 中的三元运算符可以用 if else 实现 如果大括号{}内的逻辑代码只有一行，大括号可以省略。如果省略大括号，if 只对最近 的一行逻辑代码起作用。
// Java
// int result = flag?1:0
// Scala
println("input age")
var age = StdIn.readInt()
val res:Any = if (age < 18) "童年" else "成年"
"不起作用"
println(res)嵌套分支
在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支的结构称为内层。 分支外面的分支结构称为外层分支。嵌套分支不要超过 3 层。
//需求：如果输入的年龄小于 18，返回“童年”。如果输入的年龄大于等于 18，需要再判
//断：如果年龄大于等于 18 且小于 30，返回“中年”；如果其他，返回“老年”。
println("input age")
var age = StdIn.readInt()
val res :String = if (age < 18){
"童年"
}else {
if(age>=18 && age<30){
"中年"
}else{
"老年"
}
}
println(res)Switch 分支结构
在 Scala 中没有 Switch，而是使用模式匹配来处理。（在后文）
For 循环控制
Scala 也为 for 循环这一常见的控制结构提供了非常多的特性，这些 for 循环的特性被称为 for 推导式或 for 表达式。
**范围数据循环（To） **
基本语法
（1）i 表示循环的变量，<- 规定 to （2)i 将会从 1-3 循环，前后闭合
案例实操
package chapter04
object ForLoop {
def main(args: Array[String]): Unit = {
for (i <- 1 to 3){
println(i + ". hello world")
}
}
}范围数据循环（Until）
基本语法
（1）这种方式和前面的区别在于 i 是从 1 到 3-1 （2)即前闭后开的范围
案例实操
for (i <- 1 until 4){
println(i + ". hello world")
}循环守卫
基本语法
（1）循环守卫，即循环保护式（也称条件判断式，守卫）。保护式为 true 则进入循环 体内部，为 false 则跳过，类似于 continue。 （2）上面的代码等价 
案例实操
for (i <- 1 to 3 if i != 2){
println(i)
}循环步长
基本语法
by 表示步长
案例实操
//输出 1 到 10 以内的所有奇数
for (i <- 1 to 10 by 2){
println(i)
}嵌套循环
基本语法
//方式1：
//说明：没有关键字，所以范围后一定要加；来隔断逻辑
for (i <- 1 to 3; j <- 1 to 4){
println("i = " + i + ", j = " + j)
}
println("-------------------")
//方式2：
for (i <- 1 to 3){
for (j <- 1 to 4){
println("i = " + i + ", j = " + j)
}
}引入变量
基本语法
（1）for 推导式一行中有多个表达式时，所以要加 ; 来隔断逻辑 （2）for 推导式有一个不成文的约定：当 for 推导式仅包含单一表达式时使用圆括号， 当包含多个表达式时，一般每行一个表达式，并用花括号代替圆括号，如下 
案例实操
for(i <- 1 to 5; j = 5 - i){
println("i = " + i + ", j = " + j)
}
println("-------------------")
for{i <- 1 to 5
j = 5 - i
}{
println("i = " + i + ", j = " + j)
}
println("-------------------")
for(i <- 1 to 5){
var j = 5 - i
println("i = " + i + ", j = " + j)
}循环返回值
基本语法
说明：将遍历过程中处理的结果返回到一个新 Vector 集合中，使用 yield 关键字。 注意：开发中很少使用。
案例实操
import scala.collection.immutable
val a = for (i <- 1 to 5) yield {
i * i
}
println("a = " + a)
println("-------------------")
val b: immutable.IndexedSeq[Int] = for (i <- 1 to 5) yield i * i
println("b = " + b)
倒序打印
说明：如果想倒序打印一组数据，可以用 reverse。
//倒叙打印1到5
for(i <- 1 to 5 reverse){
print(i + "\t")
}While 和 do..While 循环控制
While 和 do..While 的使用和 Java 语言中用法相同。
While 循环控制
基本语法
说明： （1）循环条件是返回一个布尔值的表达式 （2）while 循环是先判断再执行语句 （3）与 for 语句不同，while 语句没有返回值，即整个 while 语句的结果是 Unit 类型() （4)因为 while 中没有返回值，所以当要用该语句来计算并返回结果时，就不可避免 的使用变量，而变量需要声明在 while 循环的外部，那么就等同于循环的内部对外部的变量 造成了影响，所以不推荐使用，而是推荐使用 for 循环。
案例实操
package chapter04
object WhileLoop {
def main(args: Array[String]): Unit = {
var i = 0
while (i < 10) {
println(i)
i += 1
}
}
}do..while 循环控制
基本语法
do{ 循环体(语句) 循环变量迭代 }while(循环条件) 说明： （1）循环条件是返回一个布尔值的表达式 （2）do..while 循环是先执行，再判断
案例实操
var i = 0
do {
println(i)
i += 1
} while (i < 10)循环中断
基本说明
Scala 内置控制结构特地**去掉了 **break 和 continue，是为了更好的适应函数式编程，推荐使用函数式的风格解决break和continue的功能，而不是一个关键字。Scala中使用breakable 控制结构来实现 break 和 continue 功能。
案例实操
package chapter04
import scala.util.control.Breaks
import scala.util.control.Breaks._
//import scala.util.control.Breaks.{break, breakable}
object Break {
def main(args: Array[String]): Unit = {
// 1. 采用抛出异常的方式，退出循环
try {
for (i <- 0 until 5){
if (i == 3)
throw new RuntimeException
println(i)
}
} catch {
case e: Exception => // 什么都不做，只是退出循环
}
// 2. 使用Scala中的Breaks类的break方法，实现异常的抛出和捕捉
Breaks.breakable(
for (i <- 0 until 5){
if (i == 3)
Breaks.break()
println(i)
}
)
breakable(
for (i <- 0 until 5){
if (i == 3)
break()
println(i)
}
)
println("这是循环外的代码")
}
}