Scala05_流程控制

Scala程序代码和所有编程语言代码一样，都会有特定的执行流程顺序，默认情况下是顺序执行，上一条逻辑执行完成后才会执行下一条逻辑，执行期间也可以根据某些条件执行不同的分支逻辑代码

1.分支控制

让程序有选择的的执行，分支控制有三种：

• 单分支
• 双分支
• 多分支

1. 单分支

IF…ELSE 语句是通过一条或多条语句的执行结果（true或者false）来决定执行的代码块

if(布尔表达式) {
   // 如果布尔表达式为 true 则执行该语句块
}

如果布尔表达式为 true 则执行大括号内的语句块，否则跳过大括号内的语句块，执行大括号之后的语句块。

object ScalaBranch {
    def main(args: Array[String]): Unit = {
        val b = true
        if ( b ) {
            println("true")
		}
    }
}

注意：

• 如果if语句里面只有一行代码，可以省略花括号；
• 如果有多行语句不能省略花括号；
• 如果省略了花括号，只有第一行语句才算if条件内的

2.双分支

if(布尔表达式) {
   // 如果布尔表达式为 true 则执行该语句块
} else {
   // 如果布尔表达式为 false 则执行该语句块
}

如果布尔表达式为 true 则执行接着的大括号内的语句块，否则执行else后的大括号内的语句块。

object ScalaBranch {
    def main(args: Array[String]): Unit = {
        val b = true
        if ( b ) {
            println("true")
		} else {
    		println("false")
		}
    }
}

3.多分支

if(布尔表达式1) {
   // 如果布尔表达式1为 true，则执行该语句块
} else if ( 布尔表达式2 ) {
   // 如果布尔表达式2为 true，则执行该语句块
}...
} else {
   // 上面条件都不满足的场合，则执行该语句块
}

实现一个小功能：输入年龄，如果年龄小于18岁，则输出“童年”。如果年龄大于等于18且小于等于30，则输出“青年”，如果年龄大于30小于等于50，则输出”中年”，否则，输出“老年”。

object ScalaBranch {
    def main(args: Array[String]): Unit = {
        val age = 30
        if ( age < 18 ) {
            println("童年")
        } else if ( age <= 30 ) {
            println("青年")
        } else if ( age <= 50 ) {
            println("中年")
        } else {
            println("老年")
        }
    }
}

4.分支控制语句也是表达式

实际上，表达式都是有返回值的，所以上面的小功能还有其他的实现方式

object ScalaBranch {
    def main(args: Array[String]): Unit = {
        val age = 30
        val result = if ( age < 18 ) {
            "童年"
        } else if ( age <= 30 ) {
            "青年"
        } else if ( age <= 50 ) {
            "中年"
        } else {
            "老年"
        }
        println(result)
   }
}

1.表达式的返回值结果为表达式满足条件的最后一行逻辑代码执行结果
2.如果类型是Unit，print的就是()
3.如果多分枝语句每个条件下的返回值类型不同，那么整个表达式的返回值类型就是最小公倍数
4.分支控制中，如果不带else，会默认带有else，else子句的返回值为Unit

object Scala01_Follow {

  def main(args: Array[String]): Unit = {

    val i = 20
    //todo 1.只有个if 返回值类型是Unit和 返回值的最小公共类
    // Int 和 Unit 公共父类 是AnyVal
    val result =
      if( i == 20){
      20
    }

    //todo 2. if else 多个判断语句，返回值是最小公共类
    // Any
    val result1 =
      if(i==20){
        20
      }else{
        "abc"
      }
    
    //todo 3.AnyVal
    val result2 =
      if(i==20){
        20
      }else if(i==30){
        30
      }
  }

}

2. 循环控制

Scala语言提供了以下几种循环类型

2.1 for

2.1.1.遍历数据集

scala中数据集可以是任意类型的数据集合，如：

• 字符串
• 集合
• 数组
• …
  这里我们还没有讲到集合，数组语法，请大家不要着急，先能演示例子，后面咱们详细讲

object ScalaLoop {
    def main(args: Array[String]): Unit = {
        for ( i <- Range(1,5) ) { // 不包含5
            println("i = " + i )
        }
        for ( i <- 1 to 5 ) { // 包含5
            println("i = " + i )
        }
        for ( i <- 1 until 5 ) { // 不包含5
            println("i = " + i )
        }
    }
}

2.1.2 循环守卫

循环时可以增加条件来决定是否继续循环体的执行,这里的判断条件我们称之为循环守卫

object ScalaLoop {
    def main(args: Array[String]): Unit = {
        for ( i <- Range(1,5) if i != 3  ) {
            println("i = " + i )
        }
    }
}

2.1.3 循环步长

scala的集合也可以设定循环的增长幅度，也就是所谓的步长step

object ScalaLoop {
    def main(args: Array[String]): Unit = {
        for ( i <- Range(1,5,2) ) {
            println("i = " + i )
        }
        for ( i <- 1 to 5 by 2 ) {
            println("i = " + i )
        }
    }
}

2.1.4 循环嵌套

object ScalaLoop {
    def main(args: Array[String]): Unit = {
    	//写法1
        for ( i <- Range(1,5); j <- Range(1,4) ) {
            println("i = " + i + ",j = " + j )
        }
        //写法2
        for ( i <- Range(1,5) ) {
            for ( j <- Range(1,4) ) {
                println("i = " + i + ",j = " + j )
            }
        }
    }

两种写法区别在于第一种 在两层嵌套之间不能加逻辑
第二种可以加逻辑

2.1.5 引入变量

object ScalaLoop {
    def main(args: Array[String]): Unit = {
        for ( i <- Range(1,5); j = i - 1 ) {
            println("j = " + j )
        }
        
		for ( i <- Range(1,5)) {
			val j = i - 1 
            println("j = " + j )
        }
    }
}

2.1.6 6 循环返回值

scala所有的表达式都是有返回值的。但是这里的返回值并不一定都是有值的哟
如果希望for循环表达式的返回值有具体的值，需要使用关键字yield

object ScalaLoop {
    def main(args: Array[String]): Unit = {
        val result = for ( i <- Range(1,5) ) yield {
            i * 2
        }
        println(result)
    }
}

• 不加yield，返回值为Unit
• 这里是每次循环的结果都返回

思考题
Java中的线程有yield方法，Scala中该如何调用？
关键字可以用反引号进行引用声明

	Thread.`yield`()

2.2 while循环

while( 循环条件表达式 ) {
    循环体
}

while循环在迭代器和whilt(true)场景用的多一些

do {
    循环体
} while ( 循环条件表达式 )

2.2.1 while循环

object ScalaLoop {
    def main(args: Array[String]): Unit = {
        var i = 0
        while ( i < 5 ) {
            println(i)
            i += 1
        }
    }
}

2.2.2.do…while循环

object ScalaLoop {
    def main(args: Array[String]): Unit = {
        var i = 5
        do {
            println(i)
        } while ( i < 5 )
    }
}

2.2.3 循环中断

scala中没有continue关键字，可以用if条件代替
Scala中也没有break关键字，而是用面向对象的语法，通过对象的方法来代替的;

object Scala04_Follow_break {

  def main(args: Array[String]): Unit = {

    for ( i <- Range(1,5) ) { // 不包含5
      if(i==2){
        break
      }
      println(i)
    }
    println("继续执行")
  }
}

结果：
1
Exception in thread "main" scala.util.control.BreakControl

• break: scala.util.control.Breaks.break()
• break中什么都没做，只是抛出异常；这意味着一旦执行break,就会终止循环，并且直接抛出异常，所以for循环外的语句也没法执行了，main直接结束了

---

捕捉异常，并继续执行主方法:

import scala.util.control.Breaks.{break, breakable}
object Scala04_Follow_break {

  def main(args: Array[String]): Unit = {

    breakable{
      for ( i <- Range(1,5) ) { // 不包含5
        if(i==2){
          break
        }
        println(i)
      }
    }
    println("继续执行")
  }

}
结果：
1
继续执行

• 所以scala中实现break就是通过一个抛出异常的方法来跳出循环；
• breakable 能够捕捉异常，使得程序能够继续执行