Java基础-程序的流程控制-分支结构-循环结构

迷南。 2023-09-28 14:11 178阅读 0赞

#### 文章目录 ####

*  程序流程控制
 *   *  分支结构
     *   *  1.if分支语句
         *   *  格式一
             *  格式二
             *  格式三
             *  案例练习
         *  2.switch语句
         *   *  switch基本使用
             *  switch穿透性
             *  switch的利用
     *  循环结构
     *   *  1.for循环
         *   *  for循环基本使用
             *  for循环的案例
             *   *  1.求和
                 *  2.求奇数和
                 *  3.水仙花数
         *  2.while循环
         *   *  while循环基本使用
             *  while循环案例
         *  3.do-while循环
         *  4.三种循环的选择
         *  5.死循环
         *  6.循环嵌套
         *  7.循环控制

## 程序流程控制 ##

**流程控制语句**: Java提供了一些流程控制语句，来控制程序的执行流程。

**程序默认的是顺序结构**:

*  如果你没有写其他的结构，按照代码的先后顺序，依次执行程序中大多数的代码都是这样执行的。

**接下来我们来学习一下分支结构和循环结构**

### 分支结构 ###

#### 1.if分支语句 ####

> if分支结构:
> 
>  *  根据判定的结果（真或假）决定是否执行某个分支的代码

**If分支语句有三种格式**

##### 格式一 #####

if (条件表达式) 
    	语句体;
    }

**执行流程**:

*  首先判断条件表达式的结果，如果为true执行语句体，为 false 就不执行语句体。

**演示代码**:

public static void main(String[] args) {
        
        int heartBeat = 70;
    
        if (heartBeat > 60 && heartBeat < 100) {
        
          	// 当heartBeat满足条件时会执行, 不满足直接跳过
            System.out.println("您的心跳正常");
        }
    
        System.out.println("检查结束");
    }

**注意事项**:

*  if语句中，如果大括号控制的只有一行代码，则大括号可以省略不写。

public static void main(String[] args) {
        
        int heartBeat = 70;
    
        if (heartBeat > 60 && heartBeat < 100) System.out.println("您的心跳正常");
    
        System.out.println("检查结束");
    }

##### 格式二 #####

条件表达式为真, 执行语句体1; 条件表达式为假, 执行语句体2

if (条件表达式) {
        
      语句体1;
    } else {
        
      语句体2;
    }

**执行流程**:

*  首先判断条件表达式的结果，如果为true执行语句体1，为 false 就执行语句体2。

**演示代码**:

public static void main(String[] args) {
        
        int heartBeat = 30;
    
        if (heartBeat > 60 && heartBeat < 100) {
        
            // 满足条件执行的代码
            System.out.println("您的心跳正常");
        } else {
        
            // 不满足条件执行的代码
            System.out.println("您的心跳异常");
        }
    
        System.out.println("检查结束");
    }

##### 格式三 #####

if (条件表达式1) {
        
    	语句体1;
    } else if (条件表达式2) 
    	语句体2;
    } else if (条件表达式3) {
        
      语句体3;
    }
    ...
    else {
        
    	语句体n+1
    }

**执行流程**:

1.  先判断条件表达式1的值, 如果为true, 执行语句体1, 分支结束; 如果为false, 则判断条件表达式2的值;
2.  条件表达式2的值如果为true, 执行语句体2, 分支结束; 如果为false, 判断条件表达式3的值;
3.  以此类推 … ;
4.  如果没有任何条件为true，就执行else分支的语句体n+1

**演示代码**:

public static void main(String[] args) {
        
        int heartBeat = 30;
    
        if (heartBeat < 60) {
        
            // 条件1满足执行的代码
            System.out.println("您的心跳过低");
        } else if (heartBeat > 100){
        
            // 条件2满足执行的代码
            System.out.println("您的心跳过高");
        } else {
        
            System.out.println("您的心跳正常");
        }
    }

##### 案例练习 #####

**需求**: 键盘录入考试成绩，根据成绩所在的区间，程序打印出不同的奖励机制

*  成绩小于60, 输出不及格;
 *  成绩大于等于60, 小于70, 输出及格;
 *  成绩大于等于70, 小于90, 输出良好;
 *  成绩大于等于90输出优秀;

public static void main(String[] args) {
        
        Scanner sc = new Scanner(System.in);
    
        System.out.println("请输入您的成绩");
        int score = sc.nextInt();
    
        if (score < 60) {
        
            System.out.println("成绩不及格");
        } else if (score >= 60 && score < 70) {
        
            System.out.println("成绩及格");
        } else if (score >= 70 && score < 90) {
        
            System.out.println("成绩良好");
        } else {
        
            System.out.println("成绩优秀");
        }
    }

#### 2.switch语句 ####

> switch分支语句
> 
>  *  是匹配条件去执行分支, 适合做值匹配的分支选择, 结构清晰, 格式良好

##### switch基本使用 #####

**switch语句结构**:

switch(表达式) {
        
      case 值1:
        执行代码...;
        break;
      case 值2:
        执行代码...;
        break;
      ...
      case 值n-1;
        执行代码...;
        break;
      default: 
        执行代码n;
    }

**执行流程**:

1.  先执行表达式的值，拿着这个值去与case后的值进行匹配。
2.  匹配哪个case的值为true就执行哪个case，遇到break就跳出switch分支。
3.  如果case后的值都不匹配则执行default代码。

**案例练习**:**需求**

*  周一：埋头苦干，解决bug
 *  周二： 请求大牛程序员帮忙
 *  周三：今晚啤酒、龙虾、小烧烤
 *  周四： 主动帮助新来的女程序解决bug
 *  周五：今晚吃鸡
 *  周六：与王婆介绍的小芳相亲
 *  周日：郁郁寡欢、准备上班

public static void main(String[] args) {
        
        String weekday = "周二";
        switch (weekday) {
        
            case "周一":
                System.out.println("埋头苦干，解决bug");
                break;
            case "周二":
                System.out.println("请求大牛程序员帮忙");
                break;
            case "周三":
                System.out.println("今晚啤酒、龙虾、小烧烤");
                break;
            case "周四":
                System.out.println("主动帮助新来的女程序解决bug");
                break;
            case "周五":
                System.out.println("今晚吃鸡");
                break;
            case "周六":
                System.out.println("与王婆介绍的小芳相亲");
                break;
            case "周日":
                System.out.println("请求大牛程序员帮忙");
                break;
            default:
                System.out.println("您输入的值有误");
        }
    }

**注意事项**:

1.  **表达式类型只能是byte、short、int、char**，JDK5开始支持**枚举**，JDK7开始支持String
2.  **不支持double、float、long**。
3.  case给出的**值不允许重复，且只能是字面量，不能是变量**。

##### switch穿透性 #####

**如果代码执行到没有写break的case块，执行完后将直接进入下一个case块执行代码（而且不会进行任何匹配），直到遇到break才跳出分支，这就是switch的穿透性。**

**案例演练: 例如用上面的案例代码进行演示**

public static void main(String[] args) {
        
        String weekday = "周四";
      	// switch语句没有加break
        switch (weekday) {
        
            case "周一":
                System.out.println("埋头苦干，解决bug");
            case "周二":
                System.out.println("请求大牛程序员帮忙");
            case "周三":
                System.out.println("今晚啤酒、龙虾、小烧烤");
            case "周四":
                System.out.println("主动帮助新来的女程序解决bug");
            case "周五":
                System.out.println("今晚吃鸡");
            case "周六":
                System.out.println("与王婆介绍的小芳相亲");
            case "周日":
                System.out.println("请求大牛程序员帮忙");
            default:
                System.out.println("您输入的值有误");
        }
    }

**执行结果**: 匹配到周四之后, 后面的语句全部会执行

![在这里插入图片描述][d0905a51359246449542c9815b5fc5fc.png_pic_center]

##### switch的利用 #####

> switch并不是一个错误, 我们在某写场景是可以利用switch穿透性更好的编写代码

**我们来看下面这样一个案例**

**需求: 用户输入月份可以展示该月份的天数。**

*  1、3 、5、 7 、 8、 10、 12月份是 31天
 *  2月份是闰年为29天、非闰年为28天。
 *  4 、6 、9、 11月份 是30天

**演示代码**:

public static void main(String[] args) {
        
    		int month = 10;
    
    		switch (month) {
        
    				case 1:
    				case 3:
    				case 5:
    				case 7:
    				case 8:
    				case 10:
    				case 12:
    						System.out.println(month + "月是31天");
    						break;
    
    				case 2:
    						System.out.println(month + "月闰年为29天, 非闰年28天");
    						break;
    
    				case 4:
    				case 6:
    				case 9:
    				case 11:
    						System.out.println(month + "月是30天");
    						break;
    
    				default:
    						System.out.println("你输入的值有误");
    	}
    }

### 循环结构 ###

#### 1.for循环 ####

> **可以控制一段代码反复执行很多次**

##### for循环基本使用 #####

**for循环格式**:

for (初始化语句; 循环条件; 迭代语句)  {
        
      循环体语句(要重复执行的代码);
    }

**演示代码**:

// 输出3次HelloWorld
    for (int i = 0; i < 3; i++) {
        
      System.out.println("Hello World");
    }

**执行流程**: 详细说明

1.  循环一开始，执行初始化语句`int i = 0`
2.  然后判断循环条件`i < 3`, 此时i = 0, 返回true, 进入到循环体中执行输出: helloWorld, 然后执行迭代语句`i++` , 此时i=1了
3.  然后判断循环条件`i < 3`, 此时i = 1, 返回true, 进入到循环体中执行输出: helloWorld, 然后执行迭代语句`i++` , 此时i=2了
4.  然后判断循环条件`i < 3`, 此时i = 2, 返回true, 进入到循环体中执行输出: helloWorld, 然后执行迭代语句`i++` , 此时i=3了
5.  然后判断循环条件`i < 3`, 此时i = 3, 返回false, 循环结束

##### for循环的案例 #####

###### 1.求和 ######

**需求**: 求1-5之间的数据和，并把求和结果在控制台输出。

**分析**:

*  定义for循环使其能够依次访问到：1、2、3、4、5
 *  在循环外定义一个整数变量sum用来累加这些数据。
 *  循环结束后，输出求和变量即是结果。

**演示代码**:

public static void main(String[] args) {
        
        // 在循环外定义一个整数变量sum用来累加这些数据
        int sum = 0;
        // 定义for循环使其能够依次访问到：1、2、3、4、5
        for (int i = 1; i < 6; i++) {
        
            sum+=i;
        }
        // 循环结束后，输出求和变量即是结果
        System.out.println(sum); // 15
    }

###### 2.求奇数和 ######

**需求**: 求1-10之间的奇数和，并把求和结果在控制台输出。

**求奇数和给大家两种方式**

**方式一**:

*  定义for循环使其能够依次访问到：1、2、3、4、5… 10。
 *  在for循环中，通过if筛选出奇数
 *  在循环外定义一个整数变量sum用来累加这些数据。

**演示代码**:

public static void main(String[] args) {
        
        int sum = 0;
        for (int i = 1; i < 11; i++) {
        
            if (i % 2 != 0) {
        
                sum+=i;
            }
        }
        System.out.println(sum); // 25
    }

**方式二**:

*  定义for循环使其能够依次访问到：1、3、5 、7 、9。
 *  在循环外定义一个整数变量sum用来累加这些数据。

**演示代码**:

public static void main(String[] args) {
        
        int sum = 0;
        // i+=2 那么只会访问奇数
        for (int i = 1; i < 11; i+=2) {
        
            sum+=i;
        }
        System.out.println(sum); // 25
    }

###### 3.水仙花数 ######

**需求**：在控制台输出所有的“水仙花数”，水仙花数必须满足如下2个要求

*  水仙花数是一个三位数
 *  水仙花数的个位、十位、百位的数字立方和等于原数

**分析**:

*  定义一个for循环从“100一直到999”。
 *  每次访问到数据后，提取该数据的：个位、十位、百位数字。
 *  使用if判断：个位、十位、百位的数字立方和是否等于原数，等于则输出该数据。

**演示代码**:

public static void main(String[] args) {
        
        for (int i = 100; i < 1000; i++) {
        
            // 取出个位数的立方
            int a = i % 10;
            // 取出十位数
            int b = i / 10 %10;
            // 取出百位数
            int c = i / 100;
            // 拿到个十百位的立方和
            double sum = Math.pow(a, 3) + Math.pow(b, 3) + Math.pow(c, 3);
            if (sum == i) {
        
                System.out.println(i); // 153 370 371 407
            }
        }
    }

**输出结果**: 153 370 371 407

**问题: 如果我还想知道水仙花数的个数怎么得到**

**分析**:

*  **在循环外定义一个变量count用于记录水仙花数**。
 *  **每输出水仙花数时，让count++。**

**演示代码**:

public static void main(String[] args) {
        
        // 1.定义count变量记录个数
        int count = 0;
    
        for (int i = 100; i < 1000; i++) {
        
            int a = i % 10;
            int b = i / 10 %10;
            int c = i / 100;
            double sum = Math.pow(a, 3) + Math.pow(b, 3) + Math.pow(c, 3);
            if (sum == i) {
        
                // 2.找到一个水仙花数, 就让count加一
                count++;
                System.out.println(i);
            }
        }
    
        // 3.输出count
        System.out.println(count); // 4
    }

#### 2.while循环 ####

##### while循环基本使用 #####

**while循环格式**:

初始化语句;
    while (循环条件) {
        
      循环体语句(被重复执行的代码);
    	迭代语句;
    }

**演示代码**:

// 输出三次Hello World
    int i = 0;while (i < 3) {
        
      System.out.println("Hello World");
      i++;
    }

##### while循环案例 #####

**需求**: 世界最高山峰是珠穆朗玛峰(8848.86米=8848860毫米)，假如我有一张足够大的纸，它的厚度是0.1毫米。请问，折叠多少次，可以折成珠穆朗玛峰的高度。

**思路**: 这种不清楚要循环多少次的情况可以选择用while实现。

**分析**:

*  定义变量存储珠穆朗玛峰的高度、纸张的高度。
 *  使用while循环，循环条件是（纸张厚度<山峰高度），内部控制纸张折叠，每折叠一次，纸张厚度为原来两倍，循环外定义计数变量，每折叠依次让该变量+1

**演示代码**:

public static void main(String[] args) {
        
        // 定义变量, 存储珠穆朗玛峰高度
        double peakHeight = 8848860;
        // 定义变量, 储存纸张厚度
        double paperThickness = 0.1;
    
        // 定义一个变量, 记录折叠多少次
        int count = 0;
    
        while (paperThickness < peakHeight) {
        
            paperThickness *= 2;
            // 记录折叠次数
            count++;
        }
    
        // 输出
        System.out.println("折叠的次数" + count); // 27
    }

#### 3.do-while循环 ####

> do-while循环是先执行一次, 再判断循环条件

**do-while循环格式**:

初始化语句;
    do {
        
        循环体语句;
        迭代语句;
    } while (循环条件);

**演示代码**:

int i = 0;
    do {
        
      System.out.println(“Hello World！");
    i++;} while( i < 3);

**do-while循环的特点：一定会先执行一次循环体**

#### 4.三种循环的选择 ####

**三种循环的区别**:

*  for循环 和 while循环（先判断后执行)
 *  do…while （先执行一次后判断）

**for和while的区别**：

*  for循环和while循环的执行流程是一模一样的。
 *  如果已知循环次数建议使用for循环，如果不清楚要循环多少次建议使用while循环。
 *  for循环中，控制循环的变量只在循环中可以使用, 比如说for条件定义一个i变量, 循环外部依然可以再定义一个变量i, 不会命名冲突。
 *  While循环中，控制循环的变量在循环后还可以继续使用。

#### 5.死循环 ####

> 一直循环的执行下去，如果没有干预不会停止下来。

在开发中出现死循环是非常危险的操作

**死循环写法**

for(;;) {
        
      System.out.println("Hello World");
    }
    
    // 经典做法
    while(true) {
        
      System.out.println("Hello World");
    }
    
    do {
        
      System.out.println("Hello World");
    } while (true);

#### 6.循环嵌套 ####

循环嵌套: 顾名思义, 循环中又包含循环

**循环嵌套写法**:

for(int i = 0; i < 3; i++) {
        
    	for(int j = 0; j < 5; j++) {
        
        System.out.println("Hello World");
    	}
    }

**嵌套循环的特点**:

*  外部循环每循环一次，内部循环全部执行完一次。

**通过代码我们来学习一下循环嵌套吧**

**需求**: 在控制台使用 \* 打印出4行5列的矩形,

我们可能会按照如下方式打印

for(int i = 1; i <= 4; i++) {
        
         System.out.println("*****");
    }

**但是如果让打印20列呢, 100列呢, 那是不是要写20个或者100个 \* 号**

*  这种情况我们就可以使用循环嵌套

public static void main(String[] args) {
        
        for (int i = 0; i < 4; i++) {
        
            for (int j = 0; j < 20; j++) {
        
                // 不换行
                System.out.print("*");
            }
            System.out.println(); // 换行
        }
    }

**输出结果**:

![在这里插入图片描述][e57310062eea4fa9893b6215a90f0e50.png_pic_center]

#### 7.循环控制 ####

**跳转控制语句介绍**:

*  **break**: 跳出并结束当前所在循环的执行
 *  **continue**: 用于跳出当前循环的当次执行，进入下一次循环。

**break演示**: 例如, 我们循环1-10这十个数字, 让他们相加, 而相加到5的时候, 退出循环

public static void main(String[] args) {
        
        int sum = 0;
    
        for (int i = 1; i <= 10; i++) {
        
            if (i == 5) {
        
                break; // 退出循环
            }
            sum+=i;
        }
    
        System.out.println(sum); // 10
    }

**continue演示**: 如果我们将上面代码break换成continue, 那么就会跳过本次循环, 执行下一次循环

public static void main(String[] args) {
        
        int sum = 0;
    
        for (int i = 1; i <= 10; i++) {
        
            if (i == 5) {
        
                continue; // 退出循环
            }
            sum+=i;
        }
    
        System.out.println(sum); // 50
    }

**注意事项**:

*  **break**: 可以用于结束所在循环, 或者结束所在switch分支的执行。
 *  **continue** : 只能在循环中进行使用。

**扩展知识**:

*  **break : 可以用在嵌套循环中跳出整个外部循环的并立即结束它。**

[d0905a51359246449542c9815b5fc5fc.png_pic_center]: https://img-blog.csdnimg.cn/d0905a51359246449542c9815b5fc5fc.png#pic_center
[e57310062eea4fa9893b6215a90f0e50.png_pic_center]: https://img-blog.csdnimg.cn/e57310062eea4fa9893b6215a90f0e50.png#pic_center