当前位置：首页 > web >正文

2.4流程控制语句

web 2025/5/4 0:51:17

流程控制语句能对程序的执行流程进行控制。下面详细介绍 Java 中的各类流程控制语句。

1. 顺序结构

顺序结构是程序最基本的结构，代码会依照书写顺序依次执行。

public class SequenceStructure {public static void main(String[] args) {System.out.println("第一步");System.out.println("第二步");System.out.println("第三步");}
}

在上述代码中，语句会按照书写顺序，依次输出 “第一步”“第二步”“第三步”。

2. 选择结构

选择结构依据条件判断的结果来决定执行哪部分代码。Java 中的选择结构有 if-else 语句和 switch 语句。

`if-else` 语句

if-else 语句可分为单分支、双分支和多分支。

单分支：

public class IfSingleBranch {public static void main(String[] args) {int num = 10;if (num > 5) {System.out.println("数字大于 5");}}
}

若 num 大于 5，就会执行 if 语句块中的内容。

双分支：

public class IfElseDoubleBranch {public static void main(String[] args) {int num = 3;if (num > 5) {System.out.println("数字大于 5");} else {System.out.println("数字小于等于 5");}}
}

若 num 大于 5，执行 if 语句块；否则执行 else 语句块。

多分支：

public class IfElseMultiBranch {public static void main(String[] args) {int score = 85;if (score >= 90) {System.out.println("优秀");} else if (score >= 80) {System.out.println("良好");} else if (score >= 60) {System.out.println("及格");} else {System.out.println("不及格");}}
}

程序会依次判断条件，当某个条件为 true 时，执行对应的语句块，之后不再进行后续条件判断。

`switch` 语句

switch 语句依据表达式的值来选择执行的分支。

public class SwitchStatement {public static void main(String[] args) {int day = 3;switch (day) {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;case 7:System.out.println("星期日");break;default:System.out.println("输入无效");}}
}

当 day 的值与某个 case 后面的值相等时，就会执行该 case 语句块，若没有匹配的 case，则执行 default 语句块。break 语句用于终止 switch 语句的执行。

在 Java 7 之前，switch 表达式仅支持 byte、short、char、int 及其对应的包装类，还有枚举类型。从 Java 7 开始，switch 表达式也支持 String 类型

常量表达式：case 后面的值必须是常量表达式，不能是变量或者带有变量的表达式。
唯一性：case 标签的值必须唯一，不允许有重复的值。
终止执行：break 语句的作用是终止 switch 语句的执行。若没有 break 语句，程序会继续执行下一个 case 语句块，直至遇到 break 或者 switch 语句结束，这就是所谓的 “穿透” 现象。

可任意放置：default 标签用于处理 case 标签都不匹配的情况，它的位置可以任意放置，不一定要放在最后。不过，为了代码的可读性，通常将其放在最后。

int num = 3;
switch (num) {default:System.out.println("其他数字");break;case 1:System.out.println("数字是 1");break;case 2:System.out.println("数字是 2");break;
}

新特性：从 Java 12 开始，switch 语句得到了增强，成为了 switch 表达式，可以有返回值。使用 -> 语法，并且可以省略 break 语句。

int num = 2;
String result = switch (num) {case 1 -> "数字是 1";case 2 -> "数字是 2";default -> "其他数字";
};
System.out.println(result);

3. 循环结构

循环结构能够让一段代码重复执行。Java 中的循环结构有 for 循环、while 循环和 do-while 循环。

`for` 循环

for 循环适合在已知循环次数的情况下使用。

public class ForLoop {public static void main(String[] args) {for (int i = 0; i < 5; i++) {System.out.println("当前数字是: " + i);}}
}

在这个例子里，循环变量 i 从 0 开始，每次循环 i 自增 1，当 i 小于 5 时，继续循环。

`while` 循环

while 循环先判断条件，若条件为 true 则执行循环体。

public class WhileLoop {public static void main(String[] args) {int i = 0;while (i < 5) {System.out.println("当前数字是: " + i);i++;}}
}

在这个例子中，只有当 i 小于 5 时，才会执行循环体。

`do-while` 循环

do-while 循环先执行一次循环体，再判断条件，若条件为 true 则继续循环。

public class DoWhileLoop {public static void main(String[] args) {int i = 0;do {System.out.println("当前数字是: " + i);i++;} while (i < 5);}
}

无论初始条件是否成立，do-while 循环的循环体至少会执行一次。

4. 跳转语句

跳转语句用于改变程序的执行流程，Java 中的跳转语句有 break、continue 和 return。

`break` 语句

break 语句用于终止当前所在的循环或 switch 语句。

public class BreakStatement {public static void main(String[] args) {for (int i = 0; i < 10; i++) {if (i == 5) {break;}System.out.println("当前数字是: " + i);}}
}

当 i 等于 5 时，执行 break 语句，终止整个 for 循环。

`continue` 语句

continue 语句用于跳过当前循环体中剩余的语句，直接进入下一次循环。

public class ContinueStatement {public static void main(String[] args) {for (int i = 0; i < 10; i++) {if (i == 5) {continue;}System.out.println("当前数字是: " + i);}}
}

当 i 等于 5 时，执行 continue 语句，跳过本次循环中 System.out.println 语句，直接进入下一次循环。

`return` 语句

return 语句用于从方法中返回值，并终止方法的执行。

public class ReturnStatement {public static int sum(int a, int b) {return a + b;}public static void main(String[] args) {int result = sum(3, 5);System.out.println("两数之和是: " + result);}
}

在 sum 方法中，return a + b 语句返回两数之和，并终止 sum 方法的执行。

死循环

死循环指的是程序中一类循环结构，这类循环会持续执行，没有自然终止的条件，除非有外部干预（如程序被强制终止），循环会一直运行下去。在实际编程里，死循环有时会被用于特定需求，不过更多时候是由于编程失误产生的。

常见的死循环形式

`while` 循环实现的死循环

public class InfiniteWhileLoop {public static void main(String[] args) {while (true) {// 这里的代码会一直执行System.out.println("这是一个 while 死循环");}}
}

在这个例子中，while 循环的条件是 true，这意味着条件始终为真，循环体会一直执行。

`for` 循环实现的死循环

public class InfiniteForLoop {public static void main(String[] args) {for (;;) {// 这里的代码会一直执行System.out.println("这是一个 for 死循环");}}
}

在这个 for 循环里，没有初始化语句、条件判断语句和迭代语句，这就使得循环没有终止条件，会一直执行下去。

`do-while` 循环实现的死循环

public class InfiniteDoWhileLoop {public static void main(String[] args) {do {// 这里的代码会一直执行System.out.println("这是一个 do-while 死循环");} while (true);}
}

do-while 循环会先执行一次循环体，之后判断条件。由于条件是 true，循环体会持续执行。

死循环的用途

虽然死循环通常被视为编程错误，但在某些场景下也有实际用途，

import java.util.Scanner;public class InputListening {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);System.out.println("开始监听用户输入，输入 'quit' 退出。");while (true) {System.out.print("请输入内容: ");String input = scanner.nextLine();if ("quit".equalsIgnoreCase(input)) {System.out.println("退出监听。");break;}System.out.println("你输入的内容是: " + input);}scanner.close();}
}

嵌套循环详解

嵌套循环指的是在一个循环体内部再嵌套另一个或多个循环。外层循环每执行一次，内层循环会完整地执行一轮。嵌套循环常用于处理二维数据结构，如二维数组，或者需要多次嵌套迭代的场景。

嵌套 `for` 循环打印九九乘法表

public class MultiplicationTable {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");}System.out.println();}}
}

在这个例子中，外层 for 循环控制行数，内层 for 循环控制每行的列数。外层循环每执行一次，内层循环会根据当前 i 的值执行相应的次数，从而打印出一行乘法表。