【Java基础系列教程】第四章 Java程序流程控制

柔光的暖阳◎ 2024-04-28 13:14 85阅读 0赞

## 一、流程控制概述 ##

在Java程序中，JVM默认总是顺序执行以分号;结束的语句。但是，在实际的代码中，程序经常需要做条件判断、循环，因此，需要有多种流程控制语句，来实现程序的跳转和循环等功能。

流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。  
  
其流程控制方式采用结构化程序设计中规定的三种基本流程结构，即：  
顺序结构  
分支结构  
循环结构

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5rOi5ZOp5Liq5rOi_size_14_color_FFFFFF_t_70_g_se_x_16][]

## 二、顺序结构 ##

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

总的来说：程序按照从上到下的顺序执行。

![20210908090321372.jpg][]

**Java顺序结构示例代码：**

public class Order {
        public static void main(String[] args) {
            System.out.println(1);
            System.out.println(2);
            System.out.println(3);
        }
    }

## 三、分支结构 ##

根据条件，选择性地执行某段代码。

有if…else和switch-case两种分支语句。

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5rOi5ZOp5Liq5rOi_size_20_color_FFFFFF_t_70_g_se_x_16][]

### 3.1 if单分支语句 ###

语法:  
if(条件表达式)\{  
语句块;  
\}  
解释:  
条件表达式结果为boolean类型，当表达式结果为true,则执行语句块;否则什么都不执行！  
当语句块只有一条执行语句时，一对\{\}可以省略，但建议保留。

![20210908090451555.jpg][]

**Java if单分支示例代码：**

public class IfTest {
        public static void main(String[] args) {
            int a = 10;
            int b = 10;
    
            if(a > b){
                System.out.println("a 大于 b");
            }
    
            System.out.println("-------------");
    
            if(a==b){
                System.out.println("a 等于 b");
            }
       }
    }

**练习题:**

张浩Java成绩大于98分，而且音乐成绩大于80分，老师奖励他；或者Java成绩等于100分，音乐成绩大于70分，老师也可以奖励他.

public class Prize {
        public static void main(String[] args) {
            int score1 = 100; // 张浩的Java成绩
            int score2 = 72; // 张浩的音乐成绩
            if ( ( score1 >98&& score2 > 80 )|| ( score1 == 100 && score2 > 70 ) ){
                System.out.println("老师说:不错，奖励一个MP4！");
            }
        }
    }

### 3.2 if双分支语句 ###

语法:  
if(条件表达式)\{  
语句块A;  
\}else\{  
语句块B;  
\}  
解释:  
条件表达式结果为boolean类型，当表达式结果为true,则执行语句块A;否则执行语句块B。  
if-else语句结构，根据需要可以嵌套使用。

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5rOi5ZOp5Liq5rOi_size_17_color_FFFFFF_t_70_g_se_x_16][]

public class IfDemo {
        public static void main(String[] args) {
            int a = 10;
            int b = 10;
    
            if(a == b){
                System.out.println("a 等于 b");
            }else{
                System.out.println("a 不等于 b");
            }
    
            System.out.println("---------------");
    
            if(a > b){
                System.out.println("a 大于 b");
            }else{
                System.out.println("a 不大于 b");
            }
            
            System.out.println("---------------");
            int age = 3;
            if(age >= 3 && age < 6){
                System.out.println("符合入园年龄，可以报名。");
            }else{
                System.out.println("赶紧去上小学把。");
            }
            
       }
    }

**练习题：**

如果张浩Java考试成绩大于98分，老师就奖励他一个MP4，否则老师就罚他进行编码。

public class SimpleIf {
    	public static void main(String[] args) {
    		int score = 91; // 张浩的Java成绩
    		if (score > 98) {
    			System.out.println("老师说:不错，奖励一个MP4！");
    		} else {
    			System.out.println("老师说:惩罚进行编码！");
    		}
    	}
    }

### 3.3 if多分支语句 ###

语法：  
if(条件表达式A)\{  
语句块A;  
\}else if(条件表达式B)\{  
语句块B;  
\}...  
else if(条件表达式N)\{  
语句块N;  
\}else\{  
语句块N+1  
\}  
解释:  
所有的条件表达式结果都是boolean类型。  
如果条件表达式A结果为true,则执行语句块A，否则去判断条件表达式B；  
如果条件表达式B结果为true,则执行语句块B，否则去判断条件表达式C；  
....  
如果所有的条件表达式结果都为false,则执行语句块N+1  
else是可选的，根据需要可以省略

注：  
当多个条件是“互斥”关系(没有交集)时，条件判断语句及执行语句间顺序无所谓  
当多个条件是“非互斥”关系(有交集)时，需要根据实际情况，考虑如何定义顺序。  
当多个条件是“包含”关系时，“小上大下 / 子上父下”

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5rOi5ZOp5Liq5rOi_size_20_color_FFFFFF_t_70_g_se_x_16 1][]

**为什么使用多重if选择结构?**

问题:对学员的结业考试成绩评测  
成绩大于等于90时，评估结果为：优秀  
成绩为(80-89)时，评估结果为：良好  
成绩为(60-79)时，评估结果为：中等  
成绩小于60时，评估结果为：差

分析：将成绩分成几个连续区间判断。使用单个if选择结构无法完成，使用多个if选择结构很麻烦 ，所以要使用多重if选择结构。

int score = 70;    //考试成绩
    
    if ( score >= 90 ) {    
        System.out.println("优秀");
    } else if (score >= 80 ) {    
        System.out.println("良好");
    } else if (score >= 60 ) {    
        System.out.println("中等");
    } else {    
        System.out.println("差");
    }

**练习题：**

我想买车，买什么车决定于我在银行有多少存款  
如果我的存款超过500万，我就买凯迪拉克  
否则，如果我的存款超过100万，我就买帕萨特  
否则，如果我的存款超过50万，我就买依兰特  
否则，如果我的存款超过10万，我就买奥托  
否则，我买捷安特

请从键盘输入我的存款，并加以判断  
需要Scanner类  
1、导包，Scanner类在java.util.Scanner包下  
2、实例化Scanner对象  
3、调用Scanner类相关API，获取相应类型的变量  
注：如果输入类型不匹配，会抛出异常！

// 扫描器类
    Scanner input = new Scanner(System.in);
    // 输入int类型的值
    int money = input.nextInt(); // 我的存款，单位：万元
    // 判断
    if (money >= 500) {
        System.out.println("太好了，我可以买凯迪拉克");
    } else if (money >= 100) {
        System.out.println("不错，我可以买辆帕萨特");
    } else if (money >= 50) {
        System.out.println("我可以买辆依兰特");
    } else if (money >= 10) {
        System.out.println("至少我可以买个奥托");
    } else {
        System.out.println("看来，我只能买个捷安特了");
    }

**练习题：**

定义三个int型变量并赋值，使用三元运算符或者if-else获取这三个数中的较大数的实现

// 声明三个变量并赋值
    int num1 = 10,num2 = 20,num3 = -5;
    
    // 声明max变量，根据判断赋值
    int max;
    if(num1 >= num2 && num1 >= num3){
        max = num1;
    }else if(num2 >= num1 && num2 >= num3){
        max = num2;
    }else{
        max = num3;
    }

**练习题：**

编写一个程序，获取用户输入的狗的年龄，通过程序显示其相当于人类的年龄。如果用户输入负数，请显示一个提示信息。  
算法：狗的前两年每一年相当于人类的10.5岁，之后每增加一年就增加四岁。

int dogAge = 7;
    if(dogAge >= 0 && dogAge <= 2){
        System.out.println("相当于人的年龄：" + dogAge * 10.5);
    }else if( dogAge > 2){
        System.out.println("相当于人的年龄：" + (2 * 10.5 + (dogAge - 2) * 4));
    }else{
        System.out.println("狗狗还没出生呢！");
    }

### 3.4 嵌套if ###

**为什么使用嵌套if？**

问题：学校举行运动会，百米赛跑跑入10秒内的学生有资格进决赛，根据性别分别进入男子组和女子组。

分析：  
要判断是否能够进入决赛。  
在确定进入决赛的情况下，还要判断是进入男子组，还是进入女子组。  
  
解决：  
使用嵌套if选择结构

语法参考：  
if（条件1) \{  
if（条件2) \{  
代码块1  
\} else \{  
代码块2  
\}  
\} else \{  
代码块3  
\}

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5rOi5ZOp5Liq5rOi_size_19_color_FFFFFF_t_70_g_se_x_16][]

if(score <= 10){
        if(gender.equals("男")){
            System.out.println("进入男子组决赛！");
        }else if(gender.equals("女")){
            System.out.println("进入女子组决赛！");
        }
    }else{
        System.out.println("淘汰！");
    }

为了使 if 结构更加清晰、避免执行错误，应该把每个 if 或 else 包含的代码块都用大括号括起来；  
相匹配的一对 if 和 else 应该左对齐；  
内层的 if 结构相对于外层的 if 结构要有一定的缩进；

### 3.5 switch语句 ###

语法:  
switch(表达式)\{  
case 值1:  
语句块1;  
break;  
.....  
case 值N:  
语句块N;  
break;  
default:  
语句块default;  
\}  
解释:  
根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应case结构中，调用其执行语句。当调用完执行语句以后，则仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字或switch-case结构末尾结束为止。  
表达式在这里其实是一个值：但是必须是byte,short,int,char,枚举类型(JDK5.0新增)、String(JDK7.0新增)其中的一种。  
break不是语法中固定的，可以加也可以不加，但是如果为了打断switch的贯穿性，需要结合break使用。  
default块顺序可以变动，但要注意其执行顺序。通常，default块放在末尾，也可以省略；但是如果default放在前面,推荐添加break;  
case的顺序无所谓，case 之后只能声明常量，不能声明范围。  
程序会使用表达式值从上到下跟case后面的值进行比较，如果相等，则执行对应的语句块，否则继续向后对比；  
如果都不相等，则执行default。

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5rOi5ZOp5Liq5rOi_size_11_color_FFFFFF_t_70_g_se_x_16][]

import java.util.Scanner;
    
    public class SwitchDemo {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            System.out.println("只能输入1,2,3：");
            int a = sc.nextInt();
            switch(a){
                case 1:
                    System.out.println("one");
                    break;
                case 2:
                    System.out.println("two");
                    break;
    
                case 3:
                    System.out.println("three");
                    break;
                default:
                    System.out.println("输入错误,请重新输入");
            }
        }
    }

**练习题：**

韩嫣参加计算机编程大赛  
如果获得第一名，将参加麻省理工大学组织的1个月夏令营  
如果获得第二名，将奖励惠普笔记本电脑一部  
如果获得第三名，将奖励移动硬盘一个  
否则，不给任何奖励  
该问题属于等值判断，解决方法：  
使用多重if选择结构实现  
使用switch选择结构解决

int mingCi = 1;
    switch (mingCi) {
        case 1:
            System.out.println("参加麻省理工大学组织的1个月夏令营");
            break;
        case 2:
            System.out.println("奖励惠普笔记本电脑一部");
            break;
        case 3:
            System.out.println("奖励移动硬盘一个");
            break;
        default:
            System.out.println("没有任何奖励 ");
    }

**下列语句的执行结果**

int mingCi = 1;
     switch (mingCi){
    	    case 1:
                    System.out.println("参加麻省理工大学组织的1个月夏令营");               
            case 2:
                    System.out.println("奖励惠普笔记本电脑一部");                
            case 3:
                    System.out.println("奖励移动硬盘一个");                
            default:
                    System.out.println("没有任何奖励 ");
     }
    //如果需要每个case执行完后跳出，在每个case后不要忘记写break;

**练习题：**

对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”。  
注：switch-case结构来实现；

int score = 78;
    switch(score / 10){
        case 0:
        case 1:
        case 2:
        case 3:
        case 4:
        case 5:
            System.out.println("不及格");
            break;
        case 6:
        case 7:
        case 8:
        case 9:
        case 10:
            System.out.println("及格");
            break;
    }
    
    //更优的解决方案：
    switch(score / 60){
        case 0:
            System.out.println("不及格");
            break;
        case 1:
            System.out.println("及格");
            break;
    }

### 3.6 比较switch和多重if选择结构 ###

相同点  
都是用来处理多分支条件的结构  
不同点  
switch选择结构:只能处理等值条件判断的情况，而且条件必须是整型变量或字符型变量  
多重if选择结构:没有switch选择结构的限制，特别适合某个变量处于某个连续区间时的情况  
if 在应用中更为常见,有时switch 结构更清晰.  
注：凡是可以使用switch-case的结构，都可以使用if-else；反之不成立。

![20210908091412873.jpg][]

## 四、循环结构 ##

在某些条件满足的情况下，反复执行特定代码的功能  
有while、do…while、for三种循环语句。  
注：JDK1.5提供了foreach循环，方便的遍历集合、数组元素。

### 4.1 循环分类 ###

顺序结构或分支结构的程序语句只能 被执行一次。如果你要同样的操作执行多次，就需要使用循环结构。

![20210908091459305.jpg][]

执行一些需要重复的操作时,要用到循环流程.  
在现实与程序中会大量的用到循环流程 .

**设想:**

小明为了表示对JAVA的喜欢,想要写100句 “ JAVA我爱你! ”  
1遍: System.out.println(“JAVA我爱你!”);  
2遍: System.out.println(“JAVA我爱你!”);  
... ...  
100遍: System.out.println(“JAVA我爱你!”);

如果是1万遍呢?  
1遍: System.out.println(“JAVA我爱你!”);  
2遍: System.out.println(“JAVA我爱你!”);  
....  
7777遍... ...  
小明工作了一天,累成狗,老板还不满意他的工作...

**循环语句分类**

while循环  
do-while循环  
for循环  
单层for循环  
双层for循环  
增强for循环(foreach)  
嵌套循环

**循环语句的四个组成部分**

初始化部分(init\_statement)  
循环条件部分(test\_exp)  
循环体部分(body\_statement)  
迭代部分(alter\_statement)

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5rOi5ZOp5Liq5rOi_size_14_color_FFFFFF_t_70_g_se_x_16 1][]

### 4.2 while循环 ###

语法：  
①初始化部分  
while(②循环条件部分)｛  
③循环体部分;  
④迭代部分;  
\}

执行过程：  
①-②-③-④-②-③-④-②-③-④-...-②

解释：  
条件表达式返回值类型为boolean类型，只要条件表达式的结果为true,则一直执行语句块。

特点：先判断，再执行

注：  
不要忘记声明④迭代部分。否则，循环将不能结束，变成死循环。  
for循环和while循环可以相互转换,区别点：for循环和while循环的初始化变量作用域不同。

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5rOi5ZOp5Liq5rOi_size_13_color_FFFFFF_t_70_g_se_x_16][]

public class WhileLoop {
        public static void main(String[] args) {
            int sum = 0;
            int i = 1;
            while(i <= 10){
                sum += i;
                i++;
            }
            System.out.println("sum:"+sum);
        }
    }

**练习题:**

问题:如何用程序描述下面这个故事呢？  
为了帮助张浩尽快提高成绩，老师给他安排了每天的学习任务，  
其中上午阅读教材，学习理论部分，下午上机编程，掌握代码部分。  
老师每天检查学习成果。如果不合格，则继续进行  
分析:使用while循环的步骤  
1、分析循环条件和循环操作  
2、套用while语法写出代码  
3、检查循环是否能够退出

System.out.print("合格了吗?(y/n)：");
    String answer = input.next();
    while(answer.equals("y") == false){
        System.out.println("上午阅读教材！");
        System.out.println("下午上机编程！\n");
        System.out.print("合格了吗?(y/n)：");
        answer = input.next();
    }
    System.out.println("完成学习任务！");

### 4.3 do…while循环 ###

语法：  
①初始化部分;  
do\{  
③循环体部分  
④迭代部分  
\}while(②循环条件部分);

执行过程：  
①-③-④-②-③-④-②-③-④-...②

解释：  
先执行do对应的语句块，然后再判断循环条件，只要循环条件满足，则一直执行循环体，否则结束循环。  
特点：先执行，再判断;do-while循环至少执行一次循环体。

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5rOi5ZOp5Liq5rOi_size_10_color_FFFFFF_t_70_g_se_x_16][]

public class DoWhileLoop {
        public static void main(String[] args) {
            int sum = 0;
            int i = 1;
            do{
                sum+=i;
                i++;
            }while(i<=10);
            System.out.println("sum:"+sum);
        }
    }

**为什么需要do-while循环?**

经过几天的学习，老师给张浩一道测试题，  
让他先上机编写程序完成，  
然后老师检查是否合格。如果不合格，则继续编写。……

do{
        System.out.println("上机编写程序！");
        System.out.print("合格了吗?(y/n)");
        answer = input.next();
        System.out.println("");
    }while(!"y".equals(answer));
    
    System.out.println("恭喜你通过了测试！");

**while和do while的区别?**

执行次序不同:  
while先判断，再执行;do while先执行，再判断  
初始情况不满足循环条件时:  
while循环一次都不会执行  
do-while循环不管任何情况都至少执行一次

int number1 = 10;
    while(number1 > 10){
        System.out.println("hello:while");
        number1--;
    }
    
    int number2 = 10;
    do{
        System.out.println("hello:do-while");
        number2--;
    }while(number2 > 10);

### 4.4 for循环 ###

语法:  
for( ①初始化循环条件; ②循环条件表达式 ; ④迭代部分 )\{  
③循环操作(循环体);  
\}

执行过程:  
①-②-③-④-②-③-④-②-③-④-.....-②

解释:  
1、先执行初始化循环条件  
2、使用初始表达式值进行条件判断,如果判断为true,则执行循环操作;否则结束循环  
3、进行迭代  
4、循环迭代可以在()里面省略,在循环体里面进行迭代也可。

![2021090809210342.jpg][]

**练习题：**

循环输入某同学结业考试的5门课成绩，并计算平均分  
1、分析循环条件和循环操作  
2、套用for语法写出代码  
3、检查循环是否能够退出

// 定义sum,用来存储叠加求和
    int sum = 0;         
    // 循环5次录入5门课成绩
    for(int i = 0; i < 5; i++){  	
        System.out.print("请输入5门功课中第" + (i+1) + "门课的成绩： ");
        score = input.nextInt();  	//录入成绩
        sum = sum + score;        	//计算成绩和
    }
    // 计算平均分
    avg = sum / 5;                      
    System.out.println(name + "的平均分是：" + avg);

**三种循环对比：**

执行顺序  
先判断,后执行: while 和 for  
先执行,后判定: do-while  
适用  
循环次数确定: 一般使用for  
循环次数不确定: 一般使用while 和 do-while

### 4.5 循环嵌套 ###

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

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

设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m\*n次。

// 打印五颗星 *****
    // System.out.println("*****");
    for (int i = 1; i <= 5; i++) {
        System.out.print('*');
    }
    System.out.println("\n");
    
    /*
    	打印五次五颗星,如果定义五次上述代码,显然不太好;
    	那么就把上述代码,再放到一个循环结构中,就是嵌套循环
    	*****
    	*****
    	*****
    	*****
    	*****
    */
    for (int j = 1; j <= 5; j++) {
        for (int i = 1; i <= 5; i++) {
            System.out.print('*');
        }
        System.out.println();
    }

**打印直角三角形：**

/*			i(行号)		j(*的个数)
    	*			1			1
    	**			2			2
    	***			3			3
    	****		4			4
    	*****		5			5
    */
    for (int i = 1; i <= 5; i++) {//控制行数
        for (int j = 1; j <= i; j++) {//控制列数
            System.out.print("*");
    
        }
        System.out.println();
    }

**打印倒直角三角形：**

/*			i(行号)		j(*的个数)   规律：i + j = 5 换句话说：j = 5 - i;
    	****		1			4
    	***			2			3
    	**			3			2
    	*			4			1
    */
    for (int i = 1; i <= 4; i++) {
        for (int j = 1; j <= 5 - i; j++) {
            System.out.print("*");
        }
        System.out.println();
    }

**打印等腰三角形**

/*
    	1	    *			4个空格
    	2	   ***			3个空格
    	3	  *****			2个空格
    	4	 *******		1个空格
    	5	*********
    */
    for (int i = 1; i <= 5; i++) {
        for (int j = 5; j >= i; j--) {
            System.out.print(" ");
        }
        for (int j = 1; j <= i * 2 - 1; j++) {
            System.out.print("*");
        }
        System.out.println();
    }

总结规律:  
第一个(外层)for循环作用：控制行数

第二个(内层)for循环作用：控制列数

## 五、流程跳转 ##

break 用于do-while、while、for、switch中时，可跳出循环而执行循环后面的语句  
continue 用在循环中,跳过本次循环,执行下一次循环.

### 5.1 break ###

语法：  
循环(…) \{  
……  
break;  
……  
\}

解释：  
break语句用于终止某个语句块的执行  
break通常在循环中与条件语句一起使用

public class BreakTest {
        public static void main(String args[]) {
            for (int i = 0; i < 10; i++) {
                if (i == 3)
                    break;
                System.out.println(" i = " + i);
            }
        }
    }

**练习题：**

问题：循环录入某学生5门课的成绩并计算平均分，如果某分数录入为负，停止录入并提示录入错误  
分析：循环录入成绩，判断录入正确性：录入错误，使用break语句立刻跳出循环；否则，累加求和

public class BreakTest {
        public static void main(String args[]) {
            Scanner input = new Scanner(System.in);
            // 记录总分
            int sum = 0;
            // 循环5次录入5门课成绩
            for (int i = 0; i < 5; i++) {
                System.out.print("请输入第" + (i + 1) + "门课的成绩： ");
                int score = input.nextInt();
                // 输入负数
                if (score < 0) {
                    break;
                }
                // 累加求和
                sum = sum + score;
            }
            System.out.println("学生5门课的平均分是:" + sum / 5);
        }
    }

### 5.2 continue ###

语法：  
循环(...)\{  
....  
continue;  
....  
\}

解释：  
continue只能使用在循环结构中  
continue语句用于跳过其所在循环语句块的一次执行，继续下一次循环  
continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环

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

**练习题：**

循环录入Java课的学生成绩，统计分数大于等于80分的学生比例  
1、通过循环，获得分数大于等于80分的学生人数num  
2、判断：如果成绩<80，不执行num++，直接进入下一次循环

public class ContinueTest {
        public static void main(String args[]) {
            Scanner input = new Scanner(System.in);
            System.out.print("输入班级总人数:");
            int total = input.nextInt();
            // 统计80分以上学生数量
            int num = 0;
            // 循环输入学生成绩
            for (int i = 0; i < total; i++) {
                System.out.print("请输入第" + (i + 1) + "位学生的成绩： ");
                int score = input.nextInt();
                if (score < 80) {
                    continue;
                }
                num++;
            }
            System.out.println("80分以上的学生人数是： " + num);
            double rate = (double) num / total * 100;
            System.out.println("80分以上的学生所占的比例为：" + rate + "%");
        }
    }

### 5.3 多层循环跳转 ###

嵌套循环时: 内循环可以使用外循环中的变量，外循环每循环一次,内循环都会重新循环,并循环完内循环的所有次。  
break/continue 只会控制当前的循环，可以使用给循环设定标签的形式来控制循环.

label1: \{ ……  
label2: \{ ……  
label3: \{ ……  
break label2;  
……  
\}  
\}  
\}

### 5.4 return ###

return：并非专门用于结束循环的，它的功能是结束一个方法。当一个方法执行到一个return语句时，这个方法将被结束。

与break和continue不同的是，return直接结束整个方法，不管这个return处于多少层循环之内。

public class ReturnTest {
        public static void main(String args[]) {
            for (int i = 1; i <= 10; i++) {
                for (int j = 1; j <= 10; j++) {
                    if (i + j == 15) {
                        return;
                    }
                    System.out.println("i = " + i + ",j = " + j + ",i + j = " + (i + j));
                }
            }
    
            System.out.println("循环之后的语句");
        }
    }

### 5.5 三者对比 ###

**break和continue对比：**

使用场合不同  
break可用于switch结构和循环结构中。  
continue只能用于循环结构中。

作用不同（循环结构中）  
break语句终止某个循环，程序跳转到循环块外的下一条语句。  
continue跳出本次循环，进入下一次循环。

注：很多语言都有goto语句，goto语句可以随意将控制转移到程序中的任意一条语句上，然后执行它。但使程序容易出错。Java中的break和continue是不同于goto的

**continue、break、return三者对比：**

continue：  
跳过本次循环，继续下一次循环  
break：  
结束所在的循环。  
return：  
结束整个方法

## 六、课后练习题 ##

### 6.1 程序题 ###

**1、下面程序的输出结果**

public class OperatorTest {
        public static void main(String[] args) {
            boolean x = true;
            boolean y = false;
            short z = 40;
            if ((z++ == 40) && (y = true)) {
                z++;
            }
            if ((x = false) || (++z == 43)) {
                z++;
            }
            System.out.println("z = " + z);
        }
    }
    
    // 运行结果：z = 44

**2、编写程序：由键盘输入三个整数分别存入变量num1、num2、num3，对它们进行排序(使用 if-else if-else)，并且从小到大输出。**

Scanner scanner = new Scanner(System.in);
    System.out.println("请输入第一个整数：");
    int num1 = scanner.nextInt();
    System.out.println("请输入第二个整数：");
    int num2 = scanner.nextInt();
    System.out.println("请输入第三个整数：");
    int num3 = scanner.nextInt();
    
    if(num1 >= num2){
        if(num3 >= num1)
            System.out.println(num2 + "," + num1 + "," + num3);
        else if(num3 <= num2)
            System.out.println(num3 + "," + num2 + "," + num1);
        else
            System.out.println(num2 + "," + num3 + "," + num1);
    
    
    }else{
        if(num3 >= num2)
            System.out.println(num1 + "," + num2 + "," + num3);
        else if(num3 <= num1)
            System.out.println(num3 + "," + num1 + "," + num2);
        else
            System.out.println(num1 + "," + num3 + "," + num2);
    
    }

**3、大家都知道，男大当婚，女大当嫁。那么女方家长要嫁女儿，当然要提出一定的条件：**  
高：180cm以上；富：财富1千万以上；帅：是。  
如果这三个条件同时满足，则：“我一定要嫁给他!!!”  
如果三个条件有为真的情况，则：“嫁吧，比上不足，比下有余。”  
如果三个条件都不满足，则：“不嫁！”

Scanner scan = new Scanner(System.in);
    
    System.out.println("请输入你的身高：(cm)");
    int height = scan.nextInt();
    System.out.println("请输入你的财富：(千万)");
    double wealth = scan.nextDouble();
    
    /*
    		方式一：
    		System.out.println("请输入你是否帅：(true/false)");
    		boolean isHandsome = scan.nextBoolean();
    
    		if(height >= 180 && wealth >= 1 && isHandsome){
    			System.out.println("我一定要嫁给他!!!");
    		}else if(height >= 180 || wealth >= 1 || isHandsome){
    			System.out.println("嫁吧，比上不足，比下有余。");
    		}else{
    			System.out.println("不嫁！");
    		}
    		*/
    
    //方式二：
    System.out.println("请输入你是否帅：(是/否)");
    String isHandsome = scan.next();
    
    
    if(height >= 180 && wealth >= 1 && isHandsome.equals("是")){
        System.out.println("我一定要嫁给他!!!");
    }else if(height >= 180 || wealth >= 1 || isHandsome.equals("是")){
        System.out.println("嫁吧，比上不足，比下有余。");
    }else{
        System.out.println("不嫁！");
    }

**4、题目：输入两个正整数m和n，求其最大公约数和最小公倍数。**  
比如：12和20的最大公约数是4，最小公倍数是60。  
说明：break关键字的使用：一旦在循环中执行到break，就跳出循环。

Scanner scan = new Scanner(System.in);
    
    System.out.println("请输入第一个正整数：");
    int m = scan.nextInt();
    
    System.out.println("请输入第二个正整数：");
    int n = scan.nextInt();
    
    //获取最大公约数
    //1.获取两个数中的较小值
    int min = (m <= n)? m : n;
    //2.遍历
    for(int i = min;i >= 1 ;i--){
        if(m % i == 0 && n % i == 0){
            System.out.println("最大公约数为：" + i);
            break;//一旦在循环中执行到break，就跳出循环
        }
    }
    
    //获取最小公倍数
    //1.获取两个数中的较大值
    int max = (m >= n)? m : n;
    //2.遍历
    for(int i = max;i <= m * n;i++){
        if(i % m == 0 && i % n == 0){
            System.out.println("最小公倍数：" + i);
            break;
        }
    }

**5、求出1-100之间偶数和、奇数和，并分别记录奇偶数的个数。**

int evenSum = 0; // 偶数和
    int evenCount = 0;
    int oddSum = 0; // 奇数和
    int oddCount = 0;
    for(int i = 1;i <= 100;i++){
        if(i % 2 == 0){ // 偶数
            evenSum += i;
            evenCount++;
        }else{
            oddSum += i;
            oddCount++;
        }
    }
    System.out.println("偶数和:"+evenSum+",偶数个数:"+evenCount);
    System.out.println("奇数和:"+oddSum+",奇数个数:"+oddCount);

**6、1~10之间的整数相加，得到累加值大于20的当前数。**

int sum = 0;
    for(int i = 1;i <= 10;i++){
        sum += i;
        if(sum > 20){
            // 1 + 2 + 3 + 4 + 5 + 6
            System.out.println("当前和是:"+sum+",当前数是:"+i);
            break;
        }
    }

**7、判断101-200之间有多少个素数，并输出所有素数。(只能被自己整除)**

/*
    * 判断101-200之间有多少个素数，并输出所有素数。(只能被自己整除)
    *   质数又称素数。一个大于1的自然数，除了1和它自身外，不能被其他自然数整除的数叫做质数；否则称为合数。
    *   判断素数的方法：用一个数分别去除2到 Math.sqrt(这个数)，如果能被整除，则表明此数不是素数，反之是素数。
    *       Math.sqrt(数值)   获取这个数值的平方根整数
    *   1、使用for循环,确定了循环次数
    *       初始值 101
    *       条件  小于等于200
    *       迭代  递增
    *   2、循环体: 拿每一个值(i)从2开始做取余,一直到这个数值的平方根
    *       循环体里需要定义内层循环
    *           内层循环判断: 判断能不能被整除,如果能被整除，则表明此数不是素数，反之是素数
    * */
    int counter = 0;
    for(int i = 101;i <= 200;i++){
        // 循环变量i,就是我们需要进行判断处理的每个数值
        // i到底是不是素数,需要内层循环都执行完毕才可以得出结论
        boolean isFlag = true; // 先假定每个值(i)都是素数
        for(int j = 2;j <= Math.sqrt(i);j++){
            if(i % j == 0){
                isFlag = false; // 如果可以被2 - 其平方根整除,那么假定不成立
                break;
            }
        }
    
        if(isFlag){
            counter ++;
            System.out.println(i);
        }
    }
    System.out.println("素数个数是:"+counter);

**8、打印出所有的"水仙花数"，所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。**

/*
    * 打印出所有的"水仙花数"，所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。
    *   1、"水仙花数"是指一个三位数,确定了取值范围,那么我们就使用for循环
    *       初始值: 100
    *       循环条件: 小于 1000
    *       迭代: 递增
    *   2、循环体: 打印出所有的"水仙花数"
    *       判断: 各位数字立方和等于该数本身
    *           153
    *               1*1*1
    *               5*5*5
    *               3*3*3
    *           百位: 数值/100      153/100 = 1
    *           十位: 数值/10%10    153/10%10 = 5
    *           各位: 数值%10       153%10 = 3
    * */
    for(int i = 100;i <= 999;i++){
        int hundreds = i / 100; // 百位
        int decade = i / 10 % 10; // 十位
        int bits = i % 10; // 各位
        int sum = hundreds * hundreds * hundreds + decade * decade * decade + bits * bits *bits;
        if(sum == i){
            System.out.println(i+"是水仙花数");
        }
    }

**9、输入一个正整数,将其分解质因数。例如：输入90,打印出90=2\*3\*3\*5。**

/*
    * 输入一个正整数,将其分解质因数。例如：输入90,打印出90=2*3*3*5。
    *   1、使用Scanner类从控制台输入一个正整数
    *       输入一个数整数n;
    *   2、用for循环从k=2开始一直遍历到k<=n; 使用for循环
    *   3、用这个数n%k求余,判断是否等于0,并且k!=n；
    *   4、如果条件成立，就输出k和*，并将n=n/k，k=1，重新遍历，直到k==n，就输出n，并跳出循环，程序结束
    * */
    Scanner input = new Scanner(System.in);
    System.out.print("请输入一个正整数:"); // 90
    int n = input.nextInt();
    System.out.print(n+" = "); // 90 =
    
    for(int k = 2;k <= n;k++){
        if(n % k == 0 && k != n){
            System.out.print(k + " * "); // 2 * 3 * 3 *
            n /= k; // 45   15  5
            k = 1;
        }else if(k == n){
            System.out.print(n); // 5
            break;
        }
    }

**10、求10的阶乘(10\*9\*...\*2\*1)**

int product = 1;
    for(int i = 10;i > 1;i--){
        product *= i;
    }
    System.out.println(product);

**11、在控制台输出九九乘法表。**

for(int i = 1;i <= 9;i++){
        for(int j = 1;j <= i;j++){
            System.out.print(j + " * " + i + " = " + j * i+"\t");
        }
        System.out.println();
    }

**12、我国最高山峰是珠穆朗玛峰：8848m，我现在有一张足够大的纸张，厚度为：0.01m。请问，我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度?**

double end = 8848;
    double start = 0.01;
    int count = 0;
    while(start < end){
        count ++;
        start *= 2;
    }
    
    System.out.println("纸张折叠了"+count+"次,高度是:"+start);

### 6.2 简答题 ###

**1、流程控制的常见结构?**  
顺序结构: 最常见的结构化程序设计流程,从上到下一步步执行;  
分支结构: 在某个节点,出现了多个分支流程;  
循环结构: 执行一些需要重复的操作时,要用到循环流程.  
  
**2、Java分支结构语句有哪些?**  
if分支语句  
if 单分支语句  
if else 双分支语句  
if else if 多分支语句  
switch开关语句

**3、Java的switch语句可以定义什么类型的值?**  
byte,short,char,int,String,枚举enum其中的一种。  
注:枚举是jdk1.5之后支持的,String是jdk1.7之后才支持的;

**4、switch语句和多重if语句的区别?**  
相同点  
都是用来处理多分支条件的结构;  
不同点  
switch选择结构:只能处理等值条件判断的情况，而且条件必须是整型变量或字符串型变量;  
多重if选择结构:不仅可以做等值比较也可以做区间值比较，特别适合某个变量处于某个连续区间时的情况;而且条件没有类型限制;  
if 在应用中更为常见,有时switch 结构更清晰。

**5、为什么0.1 + 0.2 = 0.30000000000000004?**  
十进制数在进行运算的时候,会转换为二进制进行运算,运算完成之后在转换为十进制;  
在小数运算转换过程中,可以出现误差;

**6、Java循环语句有哪些?**  
while循环  
do-while循环  
for循环  
普通for循环  
增强for循环(foreach)

**7、Java循环语句四要素?**  
初始化部分(init\_statement)  
循环条件部分(test\_exp)  
循环体部分(body\_statement)  
迭代部分(alter\_statement)

**8、结束循环的两种方式?**  
1、循环条件不成立,结束循环  
2、在循环体内部,满足某种条件,使用break强制结束循环

**9、while 和 do while的区别?**  
两者都是用来实现循环结构的;  
while是先判断后执行; do while是先执行一次后判断;  
如果初始条件成立,那么while和do while的执行结果一致;  
如果初始条件不成立,那么while什么都不执行,do while至少执行一次;

**10、for循环 和 while循环的区别?**  
两者都是用来实现循环结构的;  
语法定义不同:  
while循环,循环三要素定义在不同的地方;初始部分定义在循环外,条件定义在while后面的(),迭代定义在循环体;  
for循环,循环三要素都定义在for循环后面的(),使用;分割  
使用场景不同:  
while 用于不确定循环次数的场合;  
for 用于确定循环次数的场合;  
初始变量的作用域不同:  
while的初始变量在循环外都可以使用;  
for循环的初始变量只能在for的循环体中;

**11、for循环、while循环、do while循环的使用场景?**  
while 用于不确定循环次数的场合;  
do while 用于至少执行一次的场合;  
for 用于确定循环次数的场合;

**12、break和continue的区别?**  
使用场合不同  
break可用于switch结构和循环结构中  
continue只能用于循环结构中  
return 只能用于方法中  
作用不同  
break语句终止某个循环，程序跳转到循环块外的下一条语句。  
continue跳出本次循环，进入下一次循环  
return 用来定义方法返回值或结束方法；

**13、如果有循环多层嵌套,怎么结束指定循环?**  
break写在哪个循环里面,就是结束哪个循环;  
如果想要结束指定循环,我们可以给循环打标记,使用break 标记名; 结束指定循环  
f1:for(int i = 1;i <= 10;i++)\{  
for(int j = 1;j <= 10;j++)\{  
if(i + j == 15)\{  
// break; // break是结束内层循环  
break f1; // 结束指定循环  
\}  
System.out.println(i+" "+j);  
\}  
\}

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5rOi5ZOp5Liq5rOi_size_14_color_FFFFFF_t_70_g_se_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/9db2efa5321c456bbac8a9b3a10498bd.jpg
[20210908090321372.jpg]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/b731fe2055584cf3913017d45156fa07.jpg
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5rOi5ZOp5Liq5rOi_size_20_color_FFFFFF_t_70_g_se_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/6e0b733554624f2689889b4017966ed1.jpg
[20210908090451555.jpg]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/166c4f99bfc2497fa1fa3d86c0b5acc4.jpg
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5rOi5ZOp5Liq5rOi_size_17_color_FFFFFF_t_70_g_se_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/1691608b5b5e44dd825ffa82466cca53.jpg
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5rOi5ZOp5Liq5rOi_size_20_color_FFFFFF_t_70_g_se_x_16 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/2e7d5add9145470fa4e1f76fc3363fd1.jpg
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5rOi5ZOp5Liq5rOi_size_19_color_FFFFFF_t_70_g_se_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/f253c90b7eff447082a2b1ca3d90583b.jpg
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5rOi5ZOp5Liq5rOi_size_11_color_FFFFFF_t_70_g_se_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/d4a62367113740d284d7eb3bdfaa4bad.jpg
[20210908091412873.jpg]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/563869bf8a8d48959b7178fdaa54ac61.jpg
[20210908091459305.jpg]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/e67bf7c106db40479d8aced84c885bf9.jpg
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5rOi5ZOp5Liq5rOi_size_14_color_FFFFFF_t_70_g_se_x_16 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/caba555e2ede4fb4a84b305a60675bb1.jpg
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5rOi5ZOp5Liq5rOi_size_13_color_FFFFFF_t_70_g_se_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/96c43a594f8c4be5a4a49e29f79ebee9.jpg
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5rOi5ZOp5Liq5rOi_size_10_color_FFFFFF_t_70_g_se_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/b173e038dfa74ee78e5f3f50cb7c1842.jpg
[2021090809210342.jpg]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/28/c5d1bd141b7e4b11887205952504e2ac.jpg