4.1 程序流程控制说明
在程序中，程序运行的流程控制决定程序是如何执行的，是我们必须掌握的，主要有三大流程控制语句，顺序控制，粉质控制，循环控制
温馨提示：Scala语言中控制结构和Java语言中的控制结构基本相同，在不考虑特殊应用场景的情况下，代码书写方式以及理解方式都没有太大的区别
4.2 顺序控制说明
4.2.1 顺序控制介绍
程序从上到下逐航地执行，中间没有任何判断和跳转
4.2.2 顺序控制举例和注意事项
4.3 分支控制if-else
4.3.1 分支控制if-else介绍
让程序有选择的执行，分支控制有三种：单分支，双分支，多分支
4.3.2 单分支的使用
基本语法
if(条件表达式){
执行代码块
}
案例演示
//import scala.io.StdIn 单独的引入一个StdInimport scala.io._ // _表示将 scala.io 包的所有内容一起引入object boke_demo01 { def main(args: Array[String]): Unit = { println("输入年龄") val age = StdIn.readInt() if (age > 22) { println("age > 22") } //小的技巧，如何查看某个包下包含的内容 //1.比如我们想看 scala.io 包有什么内容 //2.将光标放在 io上即可，输入ctrl +b //3.将光标放在 StdIn上即可，输入ctrl +b,看的是StdIn源码 scala.io.StdIn }} 4.3.3 双分支
基本语法
if(条件表达式){
执行代码块1
} else {
执行代码块2
}
说明：当条件表达式成立时，即执行代码块1，否则执行代码块2
案例演示
object boke_demo01 { //编写一个程序,可以输入人的年龄,如果该同志的年龄大于18岁,则输出“age >18”。否则 ,输出 "age <= 18 " def main(args: Array[String]): Unit = { val age = 22 if (age > 18) { println("age > 18") } else { println("age <= 18") } }} 4.3.4 多分支
基本语法
if(条件表达式1){
执行代码块1
} else if(条件表达式2){
执行代码块2
}
.......
else {
执行代码块n
}
4.3.5 分支控制if-else注意事项
1) 如果大括号{}内的内容只有一行，大括号可以省略，这点和Java的规定一样
2) Scala中任意表达式都是有返回值的，也就意味着if else表达式是有返回结果的，具体返回结果的值取决于满足条件的代码体的最后一行内容
3) Scala中没有三元运算符，因为这样可以简写
案例演示
object boke_demo01 { def main(args: Array[String]): Unit = { var sumVal = 22 val result = if(sumVal > 20){ "结果大于20"//() } println("res=" + result) //返回的是() 即 Unit }} 4.4 嵌套分支
4.4.1 基本介绍
在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支结构称为内层分支，外面的分支结构称为外层分支，嵌套分支不要超过三层
4.4.2 基本结构
if(){
if(){
} else {
}
}
4.5 switch分支结构
在Scala中没有switch，而是使用模式匹配来处理 match-case
4.6 for循环控制
4.6.1 基本介绍
Scala也为for循环这一常见的控制结构提供了非常多的特性，这些for循环的特性被称为for推导式(for comprehension)或者for表达式(for expression)
4.6.2 范围数据循环方式一
案例演示
object boke_demo01 { def main(args: Array[String]): Unit = { for (i <- 1 to 3) { println(i + "") } }} 说明：i表示循环的变量，<-规定好to规定，i将会从1－3循环，前后闭合
4.6.3 范围数据循环方式二
案例演示
object boke_demo01 { def main(args: Array[String]): Unit = { for (i <- 1 until 3) { println(i + "") } }} 说明：这种方式和前面的区别在于i是从1到3减1，前闭合后开的范围，和Java的arr.length()类似，for (int i = 0; i < arr.lenght; i++){}
4.6.4 循环守卫
案例演示
object boke_demo01 { def main(args: Array[String]): Unit = { for (i <- 1 to 3 if i != 2) { println(i + "") } }} 案例说明：循环守卫，即循环保护式(也称条件判断式，守卫)，保护式为true则进入循环体内部，为false则跳过，类似于continue
上面的代码等价
object boke_demo01 { def main(args: Array[String]): Unit = { for (i <- 1 to 3) { if(i != 2){ println(i + "") } } }} 4.6.5 引入变量
案例演示
object boke_demo01 { def main(args: Array[String]): Unit = { for(i <- 1 to 3; j = 4 - i) { print(j + " ") // 3,2,1 } }} 对案例演示的说明：没有关键字，所以范围后一定要加分号来隔断逻辑
4.6.6 循环嵌套
案例演示
object boke_demo01 { def main(args: Array[String]): Unit = { for (i <- 1 to 3; j <- 1 to 3) { println(" i =" + i + " j = " + j) } //上面的写法，可以写成 println("--------------------------") for (i <- 1 to 3) { for (j <- 1 to 3) { println(" i =" + i + " j = " + j) } } }} 4.6.7 循环返回值
案例演示
object boke_demo01 { def main(args: Array[String]): Unit = { //说明 val res = for(i <- 1 to 10) yield i 含义 //1. 对1 to 10 进行遍历 //2. yield i 将每次循环得到i 放入到集合Vector中，并返回给res //3. i 这里是一个代码块，这就意味我们可以对i进行处理 //4. 下面的这个方式，就体现出scala一个重要的语法特点，就是将一个集合中个各个数据 // 进行处理，并返回给新的集合 val res = for(i <- 1 to 10) yield { if (i % 2 == 0) { i }else { i + "不是偶数" } } println(res) }} 4.6.8 使用花括号{}代替小括号()
案例演示
object boke_demo01 { def main(args: Array[String]): Unit = { for (i <- 1 to 3; j = i * 2) { println(" i= " + i + " j= " + j) } //等价 println("------------------------") for { i <- 1 to 3 j = i * 2} { println(" i= " + i + " j= " + j) } }} 对案例演示的说明
1) {}和()对于for表达式来说都可以
2) for推导式有一个不成文的约定：当for推导式仅包含单一表达式时使用小括号，当其包含多个表达式时使用花括号
3) 当使用{}来换行写表达式时，分号就不用写了
4.6.9 注意事项和细节说明
1) Scala的for循环和Java有较大差异，但是基本的原理还是一样的
2) Scala的for循环的步长是如何控制的[for(i<-Range(1,3,2))]
3) 案例演示
object boke_demo01 { def main(args: Array[String]): Unit = { for (i <- 1 to 10) { println("i=" + i) } //步长控制为2 println("-------------") //Range(1,10,2)的对应的构建方法是 //def apply(start: Int, end: Int, step: Int): Range = new Range(start, end, step) for (i <- Range(1, 10, 2)) { println("i=" + i) } //控制步长的第二种方式-for循环守卫 println("**************************") for (i <- 1 to 10 if i % 2 == 1) { println("i=" + i) } }} 4.7 while循环控制
4.7.1 基本语法
循环变量初始化
while(循环条件){
循环体(语句)
循环变量迭代
}
4.7.2 while循环应用实例
1) 输出10句“你好”
2) 代码如下
object boke_demo01 { def main(args: Array[String]): Unit = { //输出10句 你好, //1. 定义循环变量 var i = 0 //2. i < 10 条件 while (i < 10) { println("你好," + i) //循环体 i += 1 //循环变量迭代 } }} 4.7.3 注意事项和细节说明
1) 循环条件是返回一个布尔值的表达式
2) while循环是先判断再执行语句
3) 与if语句不同，While语句本身没有值，即整个While语句的结果是Unit类型的()
4) 因为while中没有返回值，所以当要用该语句来计算并返回结果时，就不可避免的使用变量，而变量需要声明在while循环的外部，那么就等同于循环的内部对外部的变量造成了影响，所以不推荐使用，而是推荐使用for循环。
4.8 do...while循环控制
4.8.1 基本语法
循环变量初始化;
do {
循环体(语句)
循环变量迭代
} while(循环条件)
4.8.2 do...while循环应用实例
object boke_demo01 { def main(args: Array[String]): Unit = { //循环输出10句 你好 var i = 0 // for do { printf(i + "你好\n") i += 1 } while (i < 10) }} 4.8.3 注意事项和细节说明
1) 循环条件是返回一个布尔值的表达式
2) do...while循环是先执行，再判断
3) 和while一样，因为do...while中没有返回值，所以当药用该语句来计算并返回结果时，就不可避免的使用变量，而变量需要声明再do...while循环的外部，那么久等于循环的内部对外部的变量造成了影响，所以不推荐使用，而是推荐使用for循环
4.9 多重循环控制
4.9.1 基本介绍
1) 将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for，while，do...while均可以作为外层循环和内层循环[建议使用两层，最多不要超过三层]
2) 实质上，就是将内层循环当成外层循环的循环体，只有当内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层循环的当次循环，开始下一次循环
3) 设外层循环次数为m，内层为n次，则内层循环体实际上需要执行m*n=mn次
4.10 while循环的中断
4.10.1 基本介绍
Scala内置控制结构特地去掉了break和continue，是为了更好的适应函数化编程，推荐使用函数式的编程风格解决break和continue的功能，而不是一个关键字
4.10.2 break应用实例
import util.control.Breaks._object boke_demo01 { def main(args: Array[String]): Unit = { var n = 1 //breakable()函数 //说明 //1. breakable 是一个高阶函数：可以接收函数的函数就是高阶函数（后面详解） //2. def breakable(op: => Unit) { // try { // op // } catch { // case ex: BreakControl => // if (ex ne breakException) throw ex // } // } // (1) op: => Unit 表示接收的参数是一个没有输入，也没有返回值的函数 // (2) 即可以简单理解可以接收一段代码块 // 3. breakable 对break()抛出的异常做了处理,代码就继续执行 // 4. 当我们传入的是代码块，Scala程序员会将() 改成{} breakable { while (n <= 20) { n += 1 println("n=" + n) if (n == 18) { //中断while //说明 //1. 在Scala中使用函数式的break函数中断循环 //2. def break(): Nothing = { throw breakException } break() } } } println("ok~~") //注意break函数，可以使用在for或者do..while breakable { for (i <- 1 to 100) { println("i=" + i) if (i == 20) { break() } } } println("ok2~~~~") }} 4.10.3 如何实现continue的效果
Scala内置控制结构特地也去掉了continue，是为了更好地适应函数化编程，可以使用if-else或者循环守卫实现continue的效果
案例演示
object boke_demo01 { def main(args: Array[String]): Unit = { //说明 //1. 1 to 10 //2. 循环守卫 if (i != 2 && i != 3) 这个条件为ture,才执行循环体 // 即当i ==2 或者 i == 3时，就跳过 for (i <- 1 to 10 if (i != 2 && i != 3)) { println("i=" + i) } //也可以写成如下的形式 println("============================") for (i <- 1 to 10) { if (i != 2 && i != 3) { println("i=" + i) } } }}