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 单独的引入一个StdIn
import 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)
}
}
}
}