JAVA进行时——流程控制

最新推荐文章于 2023-10-07 17:35:36 发布

Rain_Marginal

最新推荐文章于 2023-10-07 17:35:36 发布

阅读量216

点赞数 1

文章标签： java 开发语言算法

本文链接：https://blog.csdn.net/Rain_Marginal/article/details/130470322

版权

3.2.3 if-else语句与switch-case语句比较

5. 关键字break和continue的使用

5.1 break和continue的说明

5.2 带标签的使用

结尾

1. 流程控制

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

程序设计中的三种流程结构，即

顺序结构

程序从上到下逐行地执行，中间没有任何判断和跳转

分支结构

根据条件，选择性地执行某段代码
有 if...else 和 switch-case 两种分支语句

循环结构

根据循环条件，重复性的执行某段代码
有 for 、while 、do-while 三种循环语句
补充：JDK5.0提供了foreach循环，方便的遍历集合、数组元素，本篇不讲

2. 顺序结构

顺序结构就是程序从上到下依次执行。表达式语句都是顺序执行的。并且上一行对某个变量的修改对下一行会产生影响

如下图

注：Java中定义变量时采用合法的前向引用。如下

public static void main(String[] args) {
	int num1 = 64;
	int num2 = num1 + 2;
}

错误形式如下

public static void main(String[] args) {
	int num2 = num1 + 2;
	int num1 = 64;
}

3. 分支结构

3.1 if-else条件判断结构

3.1.1 基本语法

结构1：单分支条件判断：if

语法格式

if(条件表达式){

语句块

}

说明

条件表达式必须是布尔表达式（关系表达式或逻辑表达式）或布尔变量

执行流程

首先判断条件表达式看其结果是true还是false
如果是true就执行语句块
如果是false就不执行语句块

举例

成年人心率的正常范围是每分钟60-100次。体检时，如果心率不在此范围内，则提示需要做进一步的检查

public class IfTest {
    public static void main(String[] args){
        int heartBeats = 89;

        if(heartBeats < 60 || heartBeats > 100){
            System.out.println("你需要做进一步的检查");
        }

        System.out.println("体检结束");
    }
}

结构2：双分支条件判断：if ... else

语法格式

if(条件表达式){

语句块1；

}

else{

语句块2；

}

执行流程

首先判断条件表达式看其结果是true还是false
如果是true就执行语句块1
如果是false就执行语句块2

举例

定义一个整数，判定是偶数还是奇数

public class IfElseTest {
    public static void main(String[] args){
        int a = 10;

        if(a % 2 == 0) {
            System.out.println(a + "是偶数");
        } 
        else{
            System.out.println(a + "是奇数");
        }
    }
}

结构3：多分支条件判断：if ... else if ... else

语法格式

if (条件表达式1){

语句块1;

}

else if (条件表达式2){

语句块2;

}

······

else if (条件表达式n){

语句块n;

}

else {

语句块n+1;

}

说明

一旦条件表达式为true，则进入执行相应的语句块。执行完对应的语句块之后，就跳出当前结构

执行流程

首先判断关系表达式1看其结果是true还是false
如果是true就执行语句块1，然后结束当前多分支
如果是false就继续判断关系表达式2看其结果是true还是false
如果是true就执行语句块2，然后结束当前多分支
如果是false就继续判断关系表达式…看其结果是true还是false

······

n.如果没有任何关系表达式为true，就执行语句块n+1，然后结束当前多分支

举例

成绩为100分时，奖励小说一套；
成绩为(80，99]时，奖励小说一本；
当成绩为[60,80]时，奖励黄冈小状元一套；
其它时，胖揍一顿。

注：成绩默认在[0，100]范围内

public class IfElseTest {
    public static void main(String[] args) {

        int score = 67; //成绩
        //写法一：
        if(score == 100){
            System.out.println("奖励小说一套");
        }else if(score > 80 && score <= 99){    //错误的写法：}else if(80 < score <= 99){
            System.out.println("奖励小说一本");
        }else if(score >= 60 && score <= 80){
            System.out.println("奖励黄冈小状元一套");
        }
        else{
        	System.out.println("胖揍一顿");
        }

        //写法二：
        if(score == 100){
            System.out.println("奖励小说一套");
        }else if(score > 80){
            System.out.println("奖励小说一本");
        }else if(score >= 60){
            System.out.println("奖励黄冈小状元一套");
        }else{
            System.out.println("胖揍一顿");
        }
    }
}

注

当条件表达式之间是 “互斥” 关系时（即彼此没有交集），条件判断语句及执行语句间顺序无所谓
当条件表达式之间是 “包含” 关系时，按照 “小上大下” 循序执行，否则范围小的条件表达式将不可能被执行

3.1.2 if...else嵌套

在 if 的语句块中，或者是在 else 语句块中，又包含了另外一个条件判断（可以是单分支、双分支、多分支），就构成了嵌套结构

执行特点

如果是嵌套在if语句块中的，只有当外部的if条件满足，才会去判断内部的条件
如果是嵌套在else语句块中的，只有当外部的if条件不满足，进入else后，才会去判断内部的条件

3.1.3 其他说明

语句块只有一条执行语句时，一对 { } 可以省略，但建议保留

当if-else结构是“多选一”时，最后的 else 是可选的，根据需要可以省略

3.2 switch-case选择结构

3.2.1 基本语法

格式如下

switch(表达式) {

case 常量值1:

语句块1;

break;

case 常量值2:

语句块2;

break;

······

[default:

语句块n+1;

break;

]

}

执行流程

第1步：根据switch中表达式的值，依次匹配各个case。如果表达式的值等于某个case中的常量值，则执行对应case中的执行语句。

第2步：执行完此case的执行语句以后，

如果遇到break,则执行break并跳出当前的switch-case结构
如果没有遇到break，则会继续执行当前case之后的其它case中的执行语句。-->case穿透
······
直到遇到break关键字或执行完所有的case及default的执行语句，跳出当前的switch-case结构

注

switch(表达式)中表达式的值必须是下述几种类型之一：byte，short，char，int，枚举，String
case子句中的值必须是常量，不能是变量名或不确定的表达式值或范围
同一个switch语句，所有case子句中的常量值互不相同
break语句用来在执行完一个case分支后使程序跳出switch语句块
如果没有break，程序会顺序执行到switch结尾
default子句是可选的。同时，位置也是灵活的。当没有匹配的case时，执行default语句

举例

得到一个数，判断，0输出zero，1输出one，2输出tow，3输出three，其他输出other

public class SwitchCaseTest {
    public static void main(String args[]) {
        int num = 1;
		switch(num){
			case 0:
				System.out.println("zero");
				break;
			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("other");
				break; // 可省略
		}
    }
}

3.2.2 利用case的穿透性

在switch语句中，如果case的后面不写break，将出现穿透现象，也就是一旦匹配成功，不会在判断下一个case的值，直接向后运行，直到遇到break或者整个switch语句结束，执行终止

举例

输入指定的月份输出对应季节

import java.util.Scanner; // 导包，用于输入语句

public class SwitchCaseTest {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in); // 创建Scanner类型的对象
        System.out.print("请输入月份：");
        int month = input.nextInt(); // 调用Scanner类的相关方法

        switch(month) {
            case 1:
            case 2:
            case 12:
                System.out.println("冬季");
                break;
            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;
        }

        input.close(); // 释放资源
    }
}

3.2.3 if-else语句与switch-case语句比较

结论：凡是使用switch-case的结构都可以转换为if-else结构。反之，不成立

开发经验：如果既可以使用switch-case，又可以使用if-else，建议使用switch-case。因为效率稍高

if-else语句优势

if语句的条件是一个布尔类型值，if条件表达式为true则进入分支，可以用于范围的判断，也可以用于等值的判断，使用范围更广
switch语句的条件是一个常量值（byte,short,int,char,枚举,String），只能判断某个变量或表达式的结果是否等于某个常量值，使用场景较窄

switch-case语句优势

当条件是判断某个变量或表达式是否等于某个固定的常量值时，使用if和switch都可以，习惯上使用switch更多。因为效率稍高。当条件是区间范围的判断时，只能使用if语句
使用switch可以利用穿透性，同时执行多个分支，而if...else没有穿透性

4. 循环结构

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

循环结构的分类

for 循环
while循环
do-while循环

循环结构四要素

初始化部分
循环条件部分
循环体部分
迭代部分

4.1 for循环

语法格式

for (初始化部分; 循环条件部分; 迭代部分){

循环体部分;

}

说明

for( ; ; )中的两个；不能多也不能少
初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔
循环条件部分为boolean类型表达式，当值为false时，退出循环
可以有多个变量更新，用逗号分隔

举例

遍历1-100以内的偶数，并获取偶数的个数，获取所有的偶数的和

public class ForTest {
	public static void main(String[] args) {
        int count = 0; // 记录偶数的个数
        int sum = 0; // 记录偶数的和

        for(int i = 1;i <= 100;i++){ // 得到1到100的数

            if(i % 2 == 0){ // 判断是否为偶数
                System.out.println(i);
                count++;
                sum += i;
            }	
        }

        System.out.println("偶数的个数为：" + count);	
        System.out.println("偶数的总和为：" + sum);
    }
}

4.2 while循环

语法格式

初始化部分;

while (循环条件部分){

循环体部分;

迭代部分;

}

说明

while(循环条件)中循环条件必须是boolean类型
注意不要忘记声明迭代部分。否则，循环将不能结束，变成死循环
for循环和while循环可以相互转换。二者没有性能上的差别
for循环与while循环的区别：初始化条件部分的作用域不同

举例

遍历1-100的偶数，并计算所有偶数的和、偶数的个数

public class WhileTest {
	public static void main(String[] args) {
		int num = 1;

		int sum = 0; // 记录1-100所有的偶数的和
		int count = 0; // 记录1-100之间偶数的个数

		while(num <= 100){
			
			if(num % 2 == 0){
				System.out.println(num); // 打印出偶数
				sum += num;
				count++;
			}
			
			num++; // 迭代部分
		}
	
		System.out.println("偶数的总和为：" + sum);
		System.out.println("偶数的个数为：" + count);
	}
}

4.3、do-while循环

语法格式

初始化部分;

do {

循环体部分;

迭代部分;

} while(循环条件部分)

说明

结尾while(循环条件)中循环条件必须是boolean类型
do{}while(); 最后有一个分号
do-while结构的循环体语句是至少会执行一次，这个和for和while是不一样的
循环的三个结构for、while、do-while三者是可以相互转换的

注：do-while可用于实现游戏等，直接让其加入界面，而无需先行判断

4.4 对比三种循环结构

三种循环结构都有的四个要素

循环变量的初始化条件
循环条件
循环体语句块
循环变量的修改的迭代表达式

循环次数角度分析

do-while循环至少执行一次循环体语句
for和while循环先判断循环条件语句是否成立，然后决定是否执行循环体

如何选择

遍历有明显的循环次数（范围）的需求，选择for循环
遍历没有明显的循环次数（范围）的需求，选择while循环
如果循环体语句块至少执行一次，可以考虑使用do-while循环

注：三种循环之间完全可以互相转换，都能实现循环的功能

4.5 “无限”循环——死循环

语法格式

最简单“无限循环”格式：while(ture)，for( ; ; )

适用场景

开发中，有时并不确定需要循环多少次，需要根据循环体内部某些条件，来控制循环的结束（使用break）
如果此循环结构不能终止，则构成了死循环！开发中要避免出现死循环

举例

打印hello world

public class EndlessFor {
    public static void main(String[] args) {
        for ( ; ; ){
            System.out.println("hello world");
        }
        
        //永远无法到达的语句，编译报错
        //System.out.println("end");
    }
}

4.6 嵌套循环（或多重循环）

使用说明

所谓嵌套循环，是指一个循环结构A的循环体是另一个循环结构B。比如，for循环里面还有一个for循环，就是嵌套循环。其中，for ,while ,do-while均可以作为外层循环或内层循环

外层循环：循环结构A

内层循环：循环结构B

实质上，嵌套循环就是把内层循环当成外层循环的循环体

只有当内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的外层循环

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

技巧：外层循环控制行数，内层循环控制列数

经验：实际开发中，我们最多见到的嵌套循环是两层。一般不会出现超过三层的嵌套循环。如果将要出现，一定要停下来重新梳理业务逻辑，重新思考算法的实现，控制在三层以内。否则，可读性会很差

两个for循环嵌套循环，格式如下

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

执行特点：外层循环执行一次，内层循环执行一轮

举例

打印九九乘法表

public class ForForTest {
    public static void main(String[] args) {
        for (int i = 1; i <= 9; i++) { // 外层，定义行
            for (int j = 1; j <= i; j++) { // 内层定义列
                System.out.print(i + "*" + j + "=" + (i * j) + "\t");
            }
            System.out.println(); //换行
        }
    }
}

5. 关键字break和continue的使用

5.1 break和continue的说明

注：

很多语言都有goto语句，goto语句可以随意将控制转移到程序中的任意一条语句上，然后执行它，但使程序容易出错。Java中的break和continue是不同于goto的
break结束的是包裹break关键字的最近的一层循环
continue结束的是包裹break关键字的最近的一层循环的当次

5.2 带标签的使用

break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块
   label1: { ……
   label2:   { ……
   label3:           { ……
               break label2;
               ……
                   }
           }
           }

注

continue语句出现在多层嵌套的循环语句体中时，也可以通过标签指明要跳过的是哪一层循环
标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面

举例

class BreakContinueTest2 {
	public static void main(String[] args) {
		lable: for(int i = 1;i <= 4;i++){
		
			for(int j = 1;j <= 10;j++){
				if(j % 4 == 0){
                    // lable 在外层循环，直接结束嵌套循环
					break lable;
				}
				System.out.print(j);
			}
			System.out.println();
		}
	}
}

结尾

以上便是今天分享的流程控制的全部内容，内容可能简单些，但有些该注意的还是要注意一下，避免出错。其次，若上述内容有错误，欢迎批评指出，让我及时改正。期待下次与各位相见。

Rain_Marginal

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
3
评论
JAVA进行时——流程控制

流程控制，用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块，包含顺序结构、选择结构（if、if-else、switch-case）、循环结构（for、while、do-while）。
复制链接

扫一扫