分支和循环结构

if条件语句结构补充

 public static void main(String[] args) {
        int x=4;
        if(x>3)
            System.out.println("true");//如果不加{}   只做用与离它最近的语法
        System.out.println(" ————————————————————————");
    }

分支和循环结构

switch语句：

多分支选择语句，根据表达式的值，来执行多个操作中的一个。

表达式可以是byte、short、int、char、枚举类型。JDK 7以后，可以使用String类型；

case语句后面只能使用常量表达式；

case后的值不能重复；

某个case分支如果没有提供break语句，则继续执行下一个case后的语句；

当表达式的值与任一个case子句中的值都不匹配时，将执行default后面的语句，如果没有default子句，则程序直接跳出switch语句。

package com.zj.javabase.day4;
/*
switch（表达式）{
    case 值： 语句块   [break];
    case 值： 语句块   [break];
    case 值： 语句块   [break];
    case 值： 语句块   [break];
default :默认语句块
}
表达式值类型：byte short int char 枚举 String
case后面的值必须是常量（具体给定的值）
值不能重复
如果case后面没有break 继续执行后面的case 语句 知道遇见break
当所有case都不匹配  执行default语句块
 */
public class SwitchDemo {
    public static void main(String[] args) {
       /*
       条件运算符
       if（任意条件）{}else if（）
       switch   在值的区间比较固定  使用switch 效率高
        */
        String day="3";
        switch (day){
            case  "1":  //只能判断与switch中的值是否相等
                System.out.println("星期一");
                break;
            case  "2":
                System.out.println("星期二");
                break;
            case  "3":
                System.out.println("星期三");
                break;
            case  "4":
                System.out.println("星期四");
                break;
            default:
                System.out.println("非法值");
        }
    }
}

什么是循环

循环语句功能

在某些条件满足的情况下，反复执行特定代码的功能

循环语句的四个组成部分

循环变量的初始化

循环条件部分

循环体部分

循环变量的更新

循环语句分类

while 循环

• while语句形式为：

while（逻辑表达式）{语句；…}

• 执行过程

先判断逻辑表达式的值。若=true.则执行其后面的语句,然后再 次判断条件并反复执行，直到条件不成立为止

package com.zj.javabase.day4;
/*
   循环要素
    变量初始化
    循环条件
    循环语句
    变量的迭代

    声明变量
    while（条件）{
      循环语句
      变量的迭代
    }
    do{

    }while（条件）
    for（声明变量，条件，变量的迭代）{
       循环语句
    }
 */
public class WhileDemo {
    public static void main(String[] args) {
        //先条件判断，成立才能进入条件语句
        /*int num=1;
        while (num<=100){
            if(num%5==0){
                System.out.println(num);
            }
            num++;
        }*/
        while (true){
            int s=1;
            System.out.println(s);
        }//while类型 死循环
    }
}

do/while 循环

• do/while语句形式：

  do { 语句; … ; } while(逻辑表达式)；

• 执行过程：

  先执行语句,再判断逻辑表达式的值,若为true,再执行语句,否则结束循环.

package com.zj.javabase.day4;
/*
   循环要素
    变量初始化
    循环条件
    循环语句
    变量的迭代

    声明变量
    while（条件）{
      循环语句
      变量的迭代
    }
    do{

    }while（条件）
    for（声明变量，条件，变量的迭代）{
       循环语句
    }
 */
public class DoWhileDemo {
    public static void main(String[] args) {
       //do while  即使条件不成立也会执行一次
        //
        int num=0;/*int s=0;*/
        do{
            /*s++;         计数器
            if(s==3){
                break;           定义循环次数
            }*/
            System.out.println(num);
            num++;
        }while (num<10);
    }
}

for 循环

• for语句为如下形式

for(表达式1; 表达式2; 表达式3){语句;… ; }

• 执行过程

  首先计算表达式1，接着执行表达式2，若表达式2的值 =true，则执行循环语句，
  接着计算表达式3，再判断表达式2的值；依此重复下去，直到表达式2的值=false.

package com.zj.javabase.day4;
/*
 for(初始化变量；条件；变量迭代){
   循环体
 }
 执行流程：
  先 初始化变量  一次


  然后 条件 一次或多次
  条件成立  执行循环体  一次或多次
  变量迭代
 */
public class Fordemo {
    public static void main(String[] args) {
        /*for (int i = 0; i < 2; i++) {
            System.out.println(i);
        }*/
        /*int i = 0;
        for (; i < 1; i++) {
            System.out.println(i);
        }*/
        /*int i = 0;
        for (; i < 8; ) {
            System.out.println(i);
            i++;
        }*/
        for(;;){
            System.out.println(1);
        }/* for类型死循环*/
    }
}

break& continue

break：

break 语句用于终止某个语句块的执行。用在循环语句体中，可以强行退出循环.

continue：

continue 语句用在循环语句体中，用于终止某次循环过程，跳过循环体中continue 语句下面未执行的循环，开始下一次循环过程.

package com.zj.javabase.day4;
public class BreakDemo {
    public static void main(String[] args) {
        /*for (int i = 0; i < 10; i++) {
            System.out.println(i);
            if(i==6){
                break;//终止整个循环
            }
        }*/
        for (int i = 0; i < 10; i++) {
            if(i==6){
                continue;
            }
            System.out.println(i);
        }
    }
}

循环嵌套

•将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while均可以作为外层循环和内层循环。

•实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。

•结束外层循环

•如果需要从多层循环跳出，则需要使用标签，定义一个标签,如label，然后在需要跳出的地方，用break label就行了.

package com.zj.javabase.day4;
/*
循环嵌套
 */
public class DoubleForDemo {
    public static void main(String[] args) {
        /*
        *****
        *****
        *****
        *****
         */
        /*
        for (int j = 0; j < 5; j++) {             //控制行数
            for (int i = 0; i <=j ; i++) {          //控制列数
                System.out.print("*");
            }
            System.out.println();
        }
        */
        /*
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                if(j==5){
                    break;  //终止当前循环   但外循环继续
                }
                System.out.println("j::"+j);
            }
            System.out.println("i::"+i);
        }
        */
        as: for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                if(j==5){
                    break as;   //终止指定标签的循环
                }
                System.out.println("j::"+j);
            }
            System.out.println("i::"+i);
        }
    }
}

循环中的标签作用

as: for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                if(j==5){
                    break as;   //终止指定标签的循环
                }
                System.out.println("j::"+j);
            }
            System.out.println("i::"+i);
        }

}
}

#### 循环中的标签作用

```visual basic
as: for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                if(j==5){
                    break as;   //终止指定标签的循环
                }
                System.out.println("j::"+j);
            }
            System.out.println("i::"+i);
        }