分支与循环语句

分支语句

流程控制

分类：顺序结构、分支结构（if、switch）、循环结构(while、do…while、for)

顺序结构

顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。

分支语句

if语句

    格式：
    if(关系表达式){
    语句体；
    }

执行流程：
①首先计算关系表达式的值
②如果关系表达式的值为true就执行语句体
③如果关系表达式的值为false就不执行语句体
④继续执行后面的语句内容
示例：
判断两个值是否相等，如果相等输出：a等于b

  public static void main(String[] args) {
    
        int a=1;
        int b=1;
        if (a==b){
    
            System.out.println("a等于b");
        }
    }
​```java

if…else语句

格式：
if(关系表达式){
语句体1;
}else{
 语句体2;
};

执行流程：
①首先计算关系表达式的值
②如果关系表达式的值为true就执行语句体1
③如果关系表达式的值为false就执行语句体2
④继续执行后面的语句内容

示例：
需求：判断a是否大于b，如果是，在控制输出：a的值大于b，如果不是，在控制台输出：a的值不大于b

public static void main(String[] args) {
    
        int a=3;
        int b=1;
        if (a>b){
    
            System.out.println("a大于b");
        }else{
    
            System.out.println("a不大于b");
        }
    }

结果：a大于b

需求：任意给出一个整数，请用程序实现判断该整数是奇数还是偶数，并在控制台输出该整数是奇数还是偶数。

 public static void main(String[] args) {
    
        Scanner scanner=new Scanner(System.in);
        System.out.print("请输入数字：");
        int num=scanner.nextInt();
        if (num%2==0){
    
            System.out.println(num+"是偶数");
        }else{
    
            System.out.println(num+"是奇数");
        }

    }

if…else…if语句

格式：
if(关系表达式1){
语句体1;
}else if(关系表达式2){
 语句体2;
}
...
else{
语句体n;
}

执行流程：
①首先计算关系表达式1的值
②如果值为true就执行语句体1；如果值为false就计算关系表达式2的值③如果值为true就执行语句体2；如果值为false就计算关系表达式3的值
④…
⑤如果没有任何关系表达式为true，就执行语句体n+1。
示例：
需求：键盘录入一个星期数（1，2，…7），输出对应的星期一，星期二，…星期日

public static void main(String[] args) {
    
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入数字1-7：");
        int num = scanner.nextInt();
        if (num == 1) {
    
            System.out.println("今天是星期一");
        } else if (num == 2) {
    
            System.out.println("今天是星期二");
        } else if (num == 3) {
    
            System.out.println("今天是星期三");
        } else if (num == 4) {
    
            System.out.println("今天是星期四");
        } else if (num == 5) {
    
            System.out.println("今天是星期五");
        } else if (num == 6) {
    
            System.out.println("今天是星期六");
        } else if (num == 7) {
    
            System.out.println("今天是星期日");
        } else {
    
            System.out.println("您输入有误。");
        }

    }

需求：小明快要期末考试了，小明爸爸对他说，会根据他不同的考试成绩，送他不同的礼物，假如你可以控制小明的得分（满分100），请用程序实现小明到底该获得什么样的礼物，并在控制台输出。

public static void main(String[] args) {
    
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入成绩：");
        double num = scanner.nextDouble();
        if (num == 100) {
    
            System.out.print("你是最棒的");
        } else if (num < 100 && num >= 90) {
    
            System.out.print("很不错");
        } else if (num < 90 && num >= 75) {
    
            System.out.print("一般般：");
        } else if (num < 75 && num >= 60) {
    
            System.out.print("有点差");
        } else {
    
            System.out.print("很差");
        }
    }

switch语句

    格式：
    switch(表达式){
        case 值1:
            语句体1;
            break;
        case 值2:
            语句体2;
            break;
        ......
        default:
            语句体n;
            [break;]
         }

格式说明：
表达式：取值为byte、short、int、char，JDK5以后可以是枚举，JDK7以后可以是String。
case：后面跟的是要和表达式进行比较的值。
break：表示中断，结束的意思，用来结束switch语句。
default：表示所有情况都不匹配的时候，就执行该处的内容，和i语句的else相似。

执行流程：
①首先计算表达式的值。
②依次和case后面的值进行比较，如果有对应的值，就会执行相应的语句，在执行的过程中，遇到brealk就会结束。
③如果所有的case后面的值和表达式的值都不匹配，就会执行default里面的语句体，然后程序结束掉。
示例：输入1-7显示周几。

    Scanner scanner = new Scanner(System.in);
    int num = scanner.nextInt();
    switch (num) {
    
        case 1:
            System.out.println("今天是星期一");
            break;
        case 2:
            System.out.println("今天是星期二");
            break;
        case 3:
            System.out.println("今天是星期三");
            break;
        case 4:
            System.out.println("今天是星期四");
            break;
        case 5:
            System.out.println("今天是星期五");
            break;
        case 6:
            System.out.println("今天是星期六");
            break;
        default:
            System.out.println("今天是星期日");
            break;
    }

需求：一年有12个月，分属于春夏秋冬4个季节，键盘录入一个月份，请用程序实现判断该月份属于哪个季节，并输出。
春：3、4、5
夏：6、7、8
秋：9、10、11
冬：1、2、12

        Scanner scanner = new Scanner(System.in);
        int num = scanner.nextInt();
        switch (num) {
    
            case 3:
            case 4:
            case 5:
                System.out.println("春");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("夏");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("秋");
                break;
            default:
                System.out.println("冬");
                break;
        }

循环结构

循环结构的组成：
初始化语句：用于表示循环开启时的起始状态，简单说就是循环开始的时候什么样
条件判断语句：用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去
循环体语句：用于表示循环反复执行的内容，简单说就是循环反复执行的事情
条件控制语句：用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去

循环结构对应的语法：
初始化语句：这里可以是一条或者多条语句，这些语句可以完成一些初始化操作
条件判断语句：这里使用一个结果值为boolean类型的表达式，这个表达式能决定是否执行循环体。例如：a-3
循环体语句：这里可以是任意语句这些语句将反复执行
条件控制语句：这里通常是使用一条语句来改变变量的值，从而达到控制循环是否继续向下执行的效果。常见i++，i--这样的操作

while语句

    while(布尔表达式){
    逻辑代码（循环操作）;
    }

执行流程：
先对布尔表达式进行判断，结果为true，则执行逻辑代码。
本次执行完毕后，再次进行判断，结果仍旧为true，则再次执行逻辑代码。
直至布尔表达式的结果为false时，才会退出循环结构，执行后续代码。

示例：
需求：打印10遍“helloworld”

        int i=1;
        while (i<11){
    
            System.out.println(i+"hello world");
            i++;
        }

    while循环如果不添加条件就会变成死循环
    首次即有入口条件，先判断、再执行，适用于循环系数明确的情况

示例：
需求：计算1+2+3+…+99+100的总和

public class Main {
    
	public static void main(String[] args) {
    
	int i = 1;
        int num = 0;
        while (i < 101) {
    
            num = num + i;
            i++;
        }
        System.out.println(num);
	}
}

结果：5050

需求：计算1-100之间所有偶数的和。

public class Main {
    
	public static void main(String[] args) {
    
	int i = 0;
        int num = 0;
        while (i < 101) {
    
            num = num + i;
            i = i + 2;
        }
        System.out.println(num);
	}
}

结果：2550

do…while语句

格式：
    do{
        逻辑代码(循环操作);
        }wuile(布尔表达式);

执行流程：
先执行一次循环操作之后，再进行布尔表达式的判断。
如果结果为true，则再次执行循环操作。
如果结果为false，才会退出循环结构，执行后续代码。

示例：
需求：打印10遍“helloworld”

public static void main(String[] args) {
    
        int i = 0;
        do {
    
            System.out.println(i + "hello world");
            i++;
        } while (i < 10);
    }

需求：检查学生作业完成情况，输入教师评语，决定学生是否需要抄写代码。

    public static void main(String[] args) {
    
        Scanner scanner = new Scanner(System.in);
        char answer = 'o';
        do {
    
            System.out.println("学生抄作业！");
            System.out.println("老师审批。");
            answer = scanner.next().charAt(0);
        } while (answer != 'y');
        System.out.println("不用抄写了。");
    }

for语句

    格式：
    for(初始化语句;条件判断语句;条件控制语句){
        循环体语句;
    }

执行流程：
①执行初始化语句
②执行条件判断语句，看其结果是true还是false如果是false，循环结束如果是true，继续执行
③执行循环体语句
④执行条件控制语句
⑤回到②继续

示例：
需求：在控制台输出5次HelloWorld

        for (int i=0;i<5;i++){
    
            System.out.println("HelloWorld");
        }

需求：现有1个班级的5名同学，请通过控制台输入5名同学的分数，并计算平均分。

    public static void main(String[] args) {
    
        Scanner scanner = new Scanner(System.in);
        double num = 0;
        double sum=0;
        for (int i = 1; i <= 5; i++) {
    
            System.out.print("请输入第"+i+"位学生成绩：");
            num=scanner.nextDouble();
            sum=sum+num;
        }
        System.out.println("平均分："+sum/5);
    }

流程控制

break

程序运行遇到break即结束运行。

示例:
控制台录入5位同学成绩，如果有任何一位同学的成绩产生非法数据（不满足0~100之间的数字）时，将直接退出整合循环操作

       public static void main(String[] args) {
    
        Scanner scanner = new Scanner(System.in);
        double num = 0;
        double sum = 0;
        boolean flag = true;
        for (int i = 1; i <= 5; i++) {
    
            System.out.print("请输入第" + i + "位学生成绩：");
            num = scanner.nextDouble();
            if (num < 0 || num > 100) {
    
                System.out.println("输入错误，程序结束。");
                flag = false;
                break;
            }
            sum = sum + num;
        }
        if (flag == true) {
    
            System.out.println("平均分：" + sum / 5);
        }
    }

Continue

continue是结束本次循环、进入下一次循环

示例：
需求：计算1-100之间所有偶数的和

    public static void main(String[] args) {
    
        int count=0;
      for (int i=0; i<=100;i++){
    
          if (i%2!=0){
    
              continue;
          }
          count=count+i;
      }
        System.out.println(count);
    }

嵌套循环

    概念：在一个完整的循环结构中，嵌套另一个完整的循环结构。

需求：输出9颗*，每排每列都是三个。

    public static void main(String[] args) {
    
        for (int i = 0; i < 3; i++) {
    
            for (int j = 0; j < 3; j++) {
    
                if (j == 2) {
    
                    System.out.println("*");
                    continue;
                }
                System.out.print("*");
            }
        }
    }

需求：计算3个班，每个班5名同学的平均成绩。

    public static void main(String[] args) {
    
        Scanner scanner = new Scanner(System.in);
        double num = 0;
        double count = 0;
        for (int j = 1; j <= 3; j++) {
    
            System.out.println("第" + j + "班学生信息：");

            for (int i = 1; i < 6; i++) {
    
                System.out.print("请输入第" + j + "班，第" + i + "位学生成绩：");
                num = scanner.nextDouble();
                count = count + num;
            }
            System.out.println("第" + j + "班的平均分：" + count / 5);
            count = 0;
        }
    }

需求：打印直角三角形

    public static void main(String[] args) {
    
        for (int i = 0; i < 5; i++) {
    
            for (int j = 0; j < i; j++) {
    
                System.out.print("*");
            }
            System.out.println();
           continue;
        }
    }

需求：打印九九乘法表

    public static void main(String[] args) {
    
        for (int i = 1; i <= 9; i++) {
    
            for (int j = 1; j <= i; j++) {
    
                System.out.print(j + "*" + i + "=" + i * j + "\t\t");
            }
            System.out.println();
        }
    }

总结

·循环的概念：
    ·通过某个条件，重复的执行一段逻辑代码。
·while循环：
    ·while（）{
    }
·do while循环：
    ·do{
    }while；
·for循环：
    ·for（初始；条件；迭代）（操作}
·流程控制关键字：
    ·break、continue
·嵌套循环：
    ·在一个完整的循环结构中，嵌套另一个完整的循环结构。