流程控制

一、流程控制说明

1.1.流程控制的作用

流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。

1.2.控制语句的分类

控制语句分为三类：顺序、选择和循环。

• “顺序结构”代表“先执行a，再执行b”的逻辑。
• “条件判断结构”代表“如果…，那么…”的逻辑。
• “循环结构”代表“如果…，则再继续…”的逻辑。

这三种基本逻辑结构是相互支撑的，它们共同构成了算法的基本结构，无论怎样复杂的逻辑结构，都可以通过它们来表达。所以任何一种高级语言都具备上述两种结构。

1.3.流程控制的流程

三种流程图说明如下：

二、分支结构

2.1.if分支结构

2.1.1.单分支

语法结构:

if(布尔表达式){
    语句块
}

if语句对布尔表达式进行一次判定，若判定为真，则执行{}中的语句块，否则跳过该语句块。流程图如图所示：

案例代码如下：

package com.branch;

import java.util.Scanner;

public class Demo01 {
    public static void main(String[] args) {
        //创建一个scanner扫描器
        Scanner scanner = new Scanner(System.in);

        //给出提示信息
        System.out.print("请输入年龄：");

        //获取键盘输入的内容
        int age = scanner.nextInt();

        /*
        if-单分支：
        （1）结构：
        if(条件表达式，这个表达式的结果是一个布尔值，只能是true或者false)
            如果（）中表达式返回结果是true，那么执行{}中的代码
            如果上面的（）中的表达式返回结果是false,那么不执行{}中代码
            {}中的代码是否执行，取决于()中表达式的返回结果
         (2)下面的代码中，两个单分支拼凑出两个个选择，每个选择是独立的，依次判断执行的
         */
        if(age>=18){
            System.out.println("恭喜你，年龄符合上网要求");
        }


        if(age<18){
            System.out.println("未成年人无法上网");
        }
    }
}

2.1.2.双分支

语法结构如下：

if(布尔表达式){
语句块1
}else{
      语句块2
}

当布尔表达式为true时，执行语句块1，否则，执行语句块2。也就是else部分。流程图如图所示：

案例代码如下：

package com.branch;

import java.util.Scanner;

public class Demo02 {
    public static void main(String[] args) {
        //创建scanner对象
        Scanner scanner = new Scanner(System.in);

        //给出提示
        System.out.print("请输入年龄：");

        //接受输入的内容
        int age = scanner.nextInt();

        if(age>=18){
            System.out.println("已成年，可以上网了");
        }else {
            System.out.println("未成年人不可以上网");
        }

    }
}

2.1.3.多分支

语法结构：

if(布尔表达式1) {
        语句块1;
} else if(布尔表达式2) {
        语句块2;
}……
else if(布尔表达式n){
        语句块n;
} else {
        语句块n+1;
}

当布尔表达式1为true时，执行语句块1；否则，判断布尔表达式2，当布尔表达式2为true时，执行语句块2；否则，继续判断布尔表达式3······；如果1~n个布尔表达式均判定为假时，则执行语句块n+1，也就是else部分。流程图如图所示：

案例如下：

package com.branch;

import java.util.Scanner;

public class Demo03 {
    public static void main(String[] args) {
        //创建scanner对象
        Scanner scanner = new Scanner(System.in);

        //给出提示
        System.out.print("请输入年龄：");

        //接受输入的内容
        int age = scanner.nextInt();

        if(age>=60) {
            System.out.println("步入了老年时代");
        } else if(age>=45) {
            System.out.println("年龄大于30岁了，没时间上网");
        } else if(age>=30){
            System.out.println("年龄大于30岁了，没时间上网");
        } else {
            System.out.println("未成年人不可以上网");
        }
        
    }
}

2.1.4.嵌套分支

嵌套分支指的是在分支里面包含分支结构，一句话，在判断中还有判断，案例说明如下：

小朋友搬桌子：
年龄大于8岁，可以搬桌子；
如果年龄大于5岁，性别是男，可以搬桌子；
否则不可以搬动桌子，提示：年龄太小了，无法搬动

案例代码如下：

package com.branch;

import java.util.Scanner;

public class Demo04 {
    public static void main(String[] args) {
        //创建scanner对象
        Scanner scanner = new Scanner(System.in);

        //给出提示
        System.out.print("请输入年龄：");

        //接受输入的内容
        int age = scanner.nextInt();

        if(age>=8){
            System.out.println("可以搬动桌子");
        }else if(age>=5){
            //输入性别
            System.out.print("请输入性别：");
            String sex = scanner.next();

            //判断两个值应用的内存地址是否相等
            if (sex.equals("男")){
                System.out.println("性别为男孩，可以搬动桌子");
            }else {
                System.out.println("性别为女孩，无法搬动桌子");
            }
        }else {
            System.out.println("年龄太小了，无法搬动");
        }
    }
}

2.2.switch分支结构

switch多分支结构(多值情况)，语法结构：

switch (表达式) {
    case 值1:
         语句序列1;
         [break];
    case 值2:
         语句序列2;
         [break];
        … … …      … …
    [default:默认语句;]
}

注意：switch语句会根据表达式的值从相匹配的case标签处开始执行，一直执行到break语句处或者是switch语句的末尾。如果表达式的值与任意case值不匹配，则进入default语句（如果存在default语句的情况）。根据表达式值的不同可以执行许多不同的操作。switch语句中case标签在JDK1.5之前必须是整数（long类型除外）或者枚举，不能是字符串，在JDK1.7之后允许使用字符串(String)。大家要注意，当布尔表达式是等值判断的情况，可以使用if-else if-else多分支结构或者switch结构，如果布尔表达式区间判断的情况，则只能使用if-else if-else多分支结构。switch多分支结构的流程图如图所示：

案例说明：

 实现一个功能根据给出的学生分数，判断学生的成绩等级：
                >=90  -----A
                >=80  -----B
                >=70  -----C
                >=60  -----D
                <60   -----E

代码如下：

package com.branch;

import java.util.Scanner;

public class Demo05 {
    public static void main(String[] args) {
        //创建scanner对象
        Scanner scanner = new Scanner(System.in);

        //给出提示
        System.out.print("请输入年龄：");

        //接受输入的内容
        int score = scanner.nextInt();
        
        /*
        【1】语法结构：
                switch(){
                        case * :
                        case * :
                        .......
                }
        【2】switch后面是一个()，()中表达式返回的结果是一个等值，这个等值的类型可以为：
        int,byte,short,char,String,枚举类型
        【3】()中的等值会依次跟case后面的值进行比较，如果匹配成功，就执行:后面的代码
        【4】为了防止代码的“穿透”效果：在每个分支后面加上一个关键词break，遇到break这个分支就结束了
        【5】类似else的“兜底”“备胎”的分支：default分支
        【6】default分支可以写在任意的位置上，但是如果没有在最后一行，后面必须加上break关键字，
        如果在最后一行的话，break可以省略
        【7】相邻分支逻辑是一样的，那么就可以只保留最后一个分支，上面的都可以省去不写了
        【8】switch分支和if分支区别：
        表达式是等值判断的话--》if ，switch都可以
        如果表达式是区间判断的情况---》if最好
        【9】switch应用场合：就是等值判断，等值的情况比较少的情况下
         */

        //根据学生成绩判断等级
        switch (score){
            case 90:
                System.out.println("A");
                break;
            case 80:
                System.out.println("B");
                break;
            case 70:
                System.out.println("C");
                break;
            case 60:
                System.out.println("D");
                break;
            default:
                System.out.println("成绩登录为F,不及格");
                break;
        }

    }
}

三、循环结构

3.1.while循环

while是最基本的循环，它的结构为：

while( 布尔表达式 ) {
  //循环内容
}

只要布尔表达式为 true，循环就会一直执行下去。案例代码如下：

package com.cycle;

public class Demo01 {
    public static void main(String[] args) {
        int x = 10;
        while (x<20){
            System.out.println("x的值为："+x);
            x++;
        }
    }
}

3.2.do-while循环

对于 while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。语法结构如下：

do {
       //代码语句
}while(布尔表达式);

注意：布尔表达式在循环体的后面，所以语句块在检测布尔表达式之前已经执行了。 如果布尔表达式的值为 true，则语句块一直执行，直到布尔表达式的值为 false。

package com.cycle;

/**
 * @author : Augus
 * @date: 2023/5/15 14:54
 * @Description: com.cycle
 * @version: 1.0
 */
public class Demo02 {
    public static void main(String[] args) {
        int x = 10;
        do{
            System.out.println("x的值为："+x);
            x++;
        }while (x<20);
        
        /*
        while循环和do-while的区别:
            while:先判断，再执行
            do-while:先执行，再判断--->至少被执行一次，从第二次开始才进行判断
        什么场合使用do-while:
            while(考试是否通过){
                考试；
            }
            --->不合适
            do{
                考试；
            }while(考试是否通过);
            --->合适   
         */
    }
}

3.3.for循环

虽然所有循环结构都可以用 while 或者 do...while表示，但 Java 提供了for 循环，使一些循环结构变得更加简单。for循环执行的次数是在执行前就确定的。语法格式如下：

for (初始表达式; 布尔表达式; 迭代因子) {
          循环体;
}

注意：for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。for循环在第一次反复之前要进行初始化，即执行初始表达式；随后，对布尔表达式进行判定，若判定结果为true，则执行循环体，否则，终止循环；最后在每一次反复的时候，进行某种形式的“步进”，即执行迭代因子。

• 初始化部分设置循环变量的初值
• 条件判断部分为任意布尔表达式
• 迭代因子控制循环变量的增减

for循环在执行条件判定后，先执行的循环体部分，再执行迭代因子。for循环结构的流程图如图所示：

package com.cycle;

/**
 * @author : Augus
 * @date: 2023/5/15 15:08
 * @Description: com.cycle
 * @version: 1.0
 */
public class Demo03 {
    public static void main(String[] args) {
        for (int x = 0; x < 20; x++) {
            System.out.println("x的值为："+x);
        }

    }
}

3.4.增强for循环

Java5 引入了一种主要用于数组的增强型 for 循环。Java 增强 for 循环语法格式如下:、

for(声明语句 : 表达式)
{
   //代码句子
}

声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。

表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

package com.cycle;

public class Demo03 {
    public static void main(String[] args) {
        int[] numbers = {100, 200, 300, 400, 500};

        for (int number : numbers) {
            System.out.println("本次取值为："+number);
        }

        System.out.println("----------------------------");

        String[] names = {"丹佛掘金","洛杉矶湖人","迈阿密热火","波士顿凯尔特人"};

        for (String name : names) {
            System.out.println("本次球队的名字："+name);
        }

    }
}

3.5.终止循环

3.5.1.break 关键字

break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。break 跳出最里层的循环，并且继续执行该循环下面的语句。

语法：break 的用法很简单，就是循环结构中的一条语句：

break;

代码如下：

package com.cycle;

public class Demo03 {
    public static void main(String[] args) {
        int[] numbers = {100, 200, 300, 400, 500};

        for (int number : numbers) {
            //number等于200时跳出循环
            if(number==200){
                break;
            }
            System.out.println("本次取值为："+number);
        }

        System.out.println("----------------------------");

        String[] names = {"丹佛掘金","洛杉矶湖人","迈阿密热火","波士顿凯尔特人"};

        for (String name : names) {
            if(name.equals("洛杉矶湖人")){
                System.out.println("湖人总冠军");
                break;
            }
            System.out.println("本次球队的名字："+name);
        }

    }
}

案例二：

package com.cycle;

public class Demo04 {
    public static void main(String[] args) {
        //求100以内的整数和

        int s = 0;

        for (int i = 0; i <= 100; i++) {
            s+=i;
            while (i==50){
                System.out.println("本次累加的值为："+i+"即将结束");
                break;//这里终止的只是while循环，for循环则会继续执行
            }
        }
        System.out.println(s);
    }
}

3.5.2.continue 关键字

continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。continue的作用：结束本次循环，继续下一次循环

语法：

continue 就是循环体中一条简单的语句：

continue;

代码如下：

package com.cycle;

public class Demo05 {
    public static void main(String[] args) {
        //功能：输出100以内的偶数和
        int s = 0;

        for (int i = 0; i <= 100 ; i++) {
            if(i%2!=0){
                continue;
            }else {
                s+=i;
            }
            System.out.println("本次操作的是："+i);
        }

        System.out.println("100以内偶数的和为："+s);
    }
}

4.6.嵌套循环

嵌套循环既可以是 for循环嵌套 while 循环，也可以是 while 循环嵌套 do-while 循环 …… 即各种类型的循环都可以作为外层循环，也可以作为内层循环。
当程序遇到嵌套循环时，如果外层循环的循环条件允许，则开始执行外层循环的循环体，而内层循环将被外层循环的循环体来执行——只是内层循环需要反复执行自己的循环体而已。
当内层循环执行结束，且外层循环的循环体执行结束时，则再次计算外层循环的循环条件，决定是否再次开始执行外层循环的循环体。
根据上面分析，假设外层循环的循环次数为 n 次，内层循环的循环次数为 m 次，那么内层循环的循环体实际上需要执行 n×m 次。嵌套循环的执行流程如图

嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为 false 时，才会完全跳出内层循环，才可以结束外层循环的当次循环，开始下一次循环。下面是一个使用嵌套循环输出九九乘法表实例。

package com.cycle;

public class Demo06 {
    public static void main(String[] args) {
        System.out.println("九九乘法表");
        //外层循环
        for (int i = 1; i <= 9; i++) {
            //内层循环
            for (int j = 1; j <= i ; j++) {
                System.out.print(j+"*"+i+"="+j*i+" ");
            }
            System.out.println(" ");
        }
    }
}