4 流程控制

4.1 分支流程

4.1.1 单分支

基本语法
	if (条件表达式) {
		代码块
	}

 	println("请输入年龄")
    val age: Int = StdIn.readInt()

   if(age < 18){
      println("童年")
    }

4.2.2 双分支

基本语法
if (条件表达式) {
			语句块1
		} else {
			语句块2
		}

	println("请输入年龄")
    val age: Int = StdIn.readInt()
	if (age < 18) {
     println("童年")
    } else {
      println("成年")
   }

4.2.3 多分支

基本语法
if(条件表达式1){
			语句块1
		}else if(条件表达式2){
			语句块2
		}....else if 可以有多个
		else{
			语句块3
		}

	println("请输入年龄")
    val age: Int = StdIn.readInt()
	if (age < 18) {
      println("童年")
    } else if (age >= 18 && age < 40) {
      println("中年")
    } else {
      println("老年")
    }

4.2 嵌套分支

嵌套分支不要超过3层

		println("input age")
        var age = StdIn.readInt()

        val res :String = if (age < 18){
            "童年"
        }else {
            if(age>=18 && age<30){
                "中年"
            }else{
                "老年"
            }
        }
        println(res)

4.3 For循环

4.3.1 范围数据循环（to）

to是右包含 [1,10]

//对范围数据进行遍历    to
   	//for (i: Int <- 1.to(10) {  类型可以省略
    //在声明变量的时候，类型可以省略，因为编译器根据集合中的数据，推导出变量类型
    for (i <- 1 to 10) {   //简化
     println(i + " ")
    }

4.3.2 范围数据循环（until）

until右不包含 [1,10)

//对范围的数据进行遍历  until
    for (i <- 1 until 10) {
      println(i)
    }

4.3.3 循环守卫

在Scala语言中，没有contine 和  break 关键字
	 通过if判断模拟continue跳出本次循环功能
	 通过调用方法模拟break跳出整个循环公共

for (i <- 1 to 3){
	if (i != 2) {   //终止当前正在执行的本次循环，继续下一次
		print(i + " ")
	}
}

//还可以写成下面这样
	for (i <- 1 to 5; if i != 3) {
     	println(i)
    }

4.3.4 循环步长

对1到10所有的技术进行遍历

 //          1.to(10).by(2)
    //for (i <- 1 to 10 by 2) {   简化后的从1到10，隔二取一
    //for (i <- 1.0 to 10.0 by 0.5) {   从1.0到10.0 隔 0.5 取一个
    for (i <- 10 to 1 by -1) {   //从10到1 每一向前隔一 
        println(i)
    }

4.3.5 嵌套循环

//第一种
	for (i <- 1 to 3) {
		for (j <- 1 to 3) {
        	println("i = " + i + ", j = " + j)
        }
  	}

//第二种，简化第一种
//没有关键字，所以范围后一定要加；来隔断逻辑
   for (i <- 1 to 3; j <- 1 to 3){
    	println("i = " + i + ", j = " + j)
   }

4.3.6 循环引用变量

    for (i <- 1 to 5; j = 10 -i){
    //for {i <- 1 to 5; j = 10 -i} {  一般不用{}
      println("i = " + i + ", j = " + j)
    }

练习1：打印乘法表
//练习2：九层妖塔

   //乘法表 1
   for (i <- 1 to 9) {
      for (j <- 1 to i) {
        print(j + "*" + i + "=" + j*i + "\t" )
      }
      println()
   }
//乘法表 2
   for (i <- 1 to 9; j <- 1 to i) {
	      print(s"${j} * ${i} = ${j*i} \t")
	      if(i == j) {  //控制换行
	       	println()
	      }
   }

//等腰三角形
for (i <- 1 to 9) {
     print(" " * (9 - i))
     print("*" * (2*i -1))
     println()
}

4.3.7循环返回值

	val res: immutable.IndexedSeq[Int] = for (i <- 1 to 5) yield i
    //在原集合基础上*2，放到新集合中去
	//第一种乘2
	val res: immutable.IndexedSeq[Int] = for (i <- 1 to 5) yield i * 2    
    //第二种乘2
	val res: immutable.IndexedSeq[Int] = for (i <- 1 to 5) yield {        
		i * 2
	}
	println(res)

4.3.8 倒叙打印

for (i <- 1 to 5 reverse) {
     println(i)
}   //5  4  3  2  1 

4.4 While和do…While循环控制

//while循环，可能循环0次
var a: Int = 5
while (a >= 1) {
     println("zy stbtk")
     a -= 1
}

//do...while循环，至少循环一次

var a:Int = 5
do{
     println("sss")
     a -= 1
} while (a >=1)

4.5 循环中断

循环终止
 -continue
	终止当前正在执行的本次循环，继续下一次

 -break
	终止整个循环

 -在scala语言中，没有break和continue关键词的
	>通过在循环体中if判断实现continue效果
	>通过抛出异常的方式实现break效果
	
	Scala内置控制结构特地去掉了break和continue，是为了更好的适应函数式编程，
推荐使用函数式的风格解决break和continue的功能，而不是一个关键字。Scala中使用
breakable控制结构来实现break和continue功能。

//    try {
//      for (i <- 1 to 5) {
//        if (i == 3) {
//          throw new RuntimeException
//        }
//        println(i)
//      }
//    } catch {
//      case e:Exception =>
//    }

//    标记当前循环是可以中断的
//    Breaks.breakable(
//      for (i <- 1 to 5) {
//        if (i == 3) {
//          Breaks.break()
//        }
//        println(i)
//      }
//    )

	//最终的形态
    breakable(
      for (i <- 1 to 5) {
        if (i == 3) {  //里边只有一行代码 {} 可以省略
          break()
        }
        println(i)
      }
    )
    println("循环体之外的代码")