4.1 程序流程控制分类
① 顺序控制
② 分支控制
③ 循环控制
4.2 顺序控制
4.2.1顺序控制介绍
程序从上到下逐行地执行，中间没有任何判断和跳转。
4.2.2 顺序控制举例和注意事项
Scala中定义变量时采用合法的前向引用。如：
def main(args : Array[String]) : Unit = {
var num1 = 12
var num2 = num1 + 2
}
错误形式：
def main(args : Array[String]) : Unit = {
var num2 = num1 + 2
var num1 = 12
}
4.3 分支控制if-else
4.3.1 分支控制if-else介绍
让程序有选择的的执行,分支控制有三种:
单分支
双分支
多分支
4.3.2 单分支
基本语法
if (条件表达式) {
执行代码块
}
说明：当条件表达式为ture 时，就会执行 { } 的代码。
示例代码
object IfDemo {
def main(args: Array[String]): Unit = {
val age = 20
if (age > 18) {
println("age > 18")
}
}
}
4.3.3 双分支
基本语法
if (条件表达式) {
执行代码块1
} else {
执行代码块2
}
说明：当条件表达式成立，即执行代码块1，否则执行代码块2.
示例代码
需求：
判断一个年份是否是闰年，闰年的条件是符合下面二者之一：(1)年份能被4整除，但不能被100整除；(2)能被400整除
import scala.io.StdIn
object TestControl {
def main(args: Array[String]): Unit = {
println("year")
val year = StdIn.readInt()
if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
println("是闰年")
} else {
println("不是闰年")
}
}
}
4.3.4 多分支
基本语法
if (条件表达式1) {
执行代码块1
}else if (条件表达式2) {
执行代码块2
}……
else {
执行代码块n
}
示例代码
object IfDemo3 {
def main(args: Array[String]): Unit = {
var grade = 90
if (grade == 100) {
println("奖励一辆BMW")
} else if (grade > 80) {
println("奖励一台iphone7plus")
} else if (grade >= 60) {
println("奖励一个 iPad")
} else {
println("no")
}
}
}
4.3.5 分支控制if-else 注意事项
① 如果大括号{}内的逻辑代码只有一行，大括号可以省略, 这点和java 的规定一样。
② Scala中任意表达式都是有返回值的，也就意味着if else表达式其实是有返回结果的，具体返回结果的值取决于满足条件的代码体的最后一行内容
object Test {
def main(args: Array[String]): Unit = {
var sumVal = 10
var result = if (sumVal == 0) {
println("ok") // 此处为满足条件逻辑的最后一行内容，打印语句是没有返回值的
} else {
"nook" //此处为不满足条件逻辑的最后一行内容，此处返回值为字符串String
}
//说明明：
//1. 因为Scala在编译期间无法知道程序的逻辑是满足或不满足，所以无法推断出result变量的具体类型，
// 所以就设定为Any类型（所有类型的公共超类型）
//2. 如果if-else 的两条分支结果都是确定的并且相同的数据类型，那么result变量的类型就是直接确定了.
//3. sumVal = 10 result = nook, sumVal = 0 result = ()类似java中的void
println("res=" + result)
}
}
③ Scala中是没有三元运算符，因为可以这样简写
val result = if (flg) 1 else 0
4.3.6 嵌套分支
需求：
出票系统：根据淡旺季的月份和年龄，打印票价
4_10 旺季：
成人（18-60）：60
儿童（<18）:半价
老人（>60）:1/3
淡季：
成人：40
其他：20
import scala.io.StdIn
object TestControl {
def main(args: Array[String]): Unit = {
println("month:");
val month = StdIn.readInt()
println("age:");
val age = StdIn.readInt()
if (month >= 4 && month <= 10) {
//旺季
if (age > 60) {
println("￥20");
} else if (age >= 18) {
println("￥60");
} else {
println("￥30");
}
} else {
//淡季
if (age >= 18 && age < 60) {
println("￥40");
} else {
println("￥20");
}
}
}
}
4.4 for循环控制
4.4.1 基本介绍
Scala 也为for 循环这一常见的控制结构提供了非常多的特性，这些for 循环的特性被称为for 推导式（for comprehension）或for 表达式（for expression）
4.4.2 范围数据循环方式
基本案例
object ForTest {
def main(args: Array[String]): Unit = {
for (i <- 1 to 3) { //[1,3]
print(i + " ") //1 2 3
}
println()
for (j <- 1 until 3) { //[1,3) 顾头不顾腚
print(j + " ") // 1 2
}
}
}
4.4.3 循环守卫
基本案例
object ForTest {
def main(args: Array[String]): Unit = {
for (i <- 1 to 3 if i != 2) {
print(i + " ") //1 3
}
println()
}
}
说明
① 循环守卫，即循环保护式（也称条件判断式，守卫）。保护式为true则进入循环体内部，为false则跳过，类似于continue
② 上面的代码等价
object ForTest {
def main(args: Array[String]): Unit = {
for (i <- 1 to 3) {
if (i != 2) {
println(i + "")
}
}
}
}
4.4.4 引入变量
基本案例
for(i <- 1 to 3; j = 4 - i) {
print(j + " ")
}
说明
① 没有关键字，所以范围后一定要加；来隔断逻辑
② 上面的代码等价
for (i <- 1 to 3) {
val j = 4-i
print (j + "")
}
4.4.5 嵌套循环
基本案例
for(i <- 1 to 3; j <- 1 to 3) {
println(" i =" + i + " j = " + j)
}
说明
① 没有关键字，所以范围后一定要加；来隔断逻辑
② 上面的代码等价
for (i <- 1 to 3) {
for (j <- 1 to 3) {
println(i + " " + j + " ")
}
}
4.4.6 循环返回值
基本案例
val res = for(i <- 1 to 10) yield i
println(res)
说明
将遍历过程中处理的结果返回到一个新Vector集合中，使用yield关键字
4.4.7 使用{}代替()
基本案例
for(i <- 1 to 3; j = i * 2) {
println(" i= " + i + " j= " + j)
}
可以写成
for{
i <- 1 to 3
j = i * 2} {
println(" i= " + i + " j= " + j)
}
说明
① {}和()对于for表达式来说都可以
② for 推导式有一个不成文的约定：当for 推导式仅包含单一表达式时使用圆括号，当其包含多个表达式时使用大括号
③ 当使用{} 来换行写表达式时，分号就不用写了
4.4.8 控制步长
object ForTest {
def main(args: Array[String]): Unit = {
//如果要倒叙遍历 Range(3,1,-1)就可以了
//Range的范围和until 的规则一样
println("for Range(开始,结束,步长) :")
for (i <- Range(1, 3, 2)) {
println(i + " ") //1
}
}
}
object ForTest {
def main(args: Array[String]): Unit = {
for (i <- 1 until 7 if (i % 4 == 1)) {
println(i) //1 5
}
}
}
4.5 while循环
4.5.1 基本语法
循环变量初始化
while (循环条件) {
循环体(语句)
循环变量迭代
}
4.5.2 注意事项和细节说明
① 循环条件是返回一个布尔值的表达式
② while循环是先判断再执行语句
③ 与If语句不同，While语句本身没有值，即整个While语句的结果是Unit类型的()
④ 因为while中没有返回值,所以当要用该语句来计算并返回结果时,就不可避免的使用变量 ，而变量需要声明在while循环的外部，那么就等同于循环的内部对外部的变量造成了影响，所以不推荐使用，而是推荐使用for循环。
4.5.3 示例代码
object WhileTest {
def main(args: Array[String]): Unit = {
//打印1—100之间所有能被3整除的数
var i = 1
var max = 100
while (i <= max) {
if (i % 3 == 0) {
println(i)
}
i += 1
}
}
}
4.6 do..while循环控制
4.6.1 基本语法
循环变量初始化;
do{
循环体(语句)
循环变量迭代
} while(循环条件)
4.6.2 示例代码
object DoWhileTest {
def main(args: Array[String]): Unit = {
//计算1—100的和
var i = 1
var sum = 0
do {
//循环操作
//sum=sum+i;
sum += i
i += 1
} while (i <= 100)
println(sum)
}
}
4.7 while循环的中断
4.7.1 基本说明
Scala内置控制结构特地去掉了break和continue，是为了更好的适应函数化编程，推荐使用函数式的风格解决break和contine的功能，而不是一个关键字。
import util.control.Breaks._
object WhileBreak {
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~~~~")
}
}