Java流程控制三要素：顺序、分支与循环全解析 - 教程

不仅是Java，绝大部分的高级编程语言，都有这三种流程控制结构：顺序结构、选择结构、循环结构。

顺序结构

代码默认是从上到下按顺序执行，所以顺序结构不必多说。

选择结构

选择结构有if条件选择和Switch选择两种类型。

if 条件选择

if条件选择，有纯if、if + else、if + else if + else这几类。

纯if选择结构，若满足if的条件，则执行{}内的代码，否则不执行。

如下例子，a > b 是false，则不会执行System.out.println(“a大于b”);
if选择结构执行完毕后，按顺序结构，继续执行下一行代码System.out.println(“程序结束”);

public class Demo5 {
public static void main(String[] args) {
int a = 10;
int b = 20;
if (a > b) {
System.out.println("a大于b");
}
System.out.println("程序结束");
}
}

if + else 结构，则满足条件，则执行if 后的{}代码块的代码，否则执行else后的{}代码块的代码。

如下例子，由于a >=b 是false，则执行else后{}内的代码块，即执行System.out.println(“a小于b”)。执行完毕后，按顺序结构，继续执行下一行代码System.out.println(“程序结束”);

public class Demo6 {
public static void main(String[] args) {
int a = 10;
int b = 20;
if (a >= b) {
System.out.println("a大于等于b");
} else {
System.out.println("a小于b");
}
System.out.println("程序结束");
}
}

if + else if +else 的结构，判断if后的条件是否满足，满足则执行if 后{}代码块，不满足条件，则判断else if 后的条件，依次类推（可以有多个else if），直到最后都不满足，则执行else后的{}代码块的代码。

如下例子，先后判断a > b 和 a == b 都为false后，则执行else 后{}代码块System.out.println(“a小于b”)。执行完毕后，按顺序结构，继续执行下一行代码System.out.println(“程序结束”);

public class Demo7 {
public static void main(String[] args) {
int a = 10;
int b = 20;
if (a > b) {
System.out.println("a大于b");
} else if(a == b) {
System.out.println("a等于b");
} else {
System.out.println("a小于b");
}
System.out.println("程序结束");
}
}

Switch条件选择

Java中还有一种Switch case条件选择结构，当case匹配时，走该分支。若都不匹配case，则走default分支。与if选择结构中else非必须类似，switch结构中default分支也是非必须的。

与if选择结构不同，switch后接表达式返回值并不是布尔值，而可以是char、int变量类型，甚至是string等引用变量类型。当表达式与某case匹配时，执行该分支{}代码块。

public class Demo8 {
public static void main(String[] args) {
// 编写一个switch case结构，判断一个字符是否是字母a、b、c、d  
char ch = 'a';
switch (ch) {
case 'a': {
System.out.println("字母a");
break;
}
case 'b': {
System.out.println("字母b");
break;
}
case 'c': {
System.out.println("字母c");
break;
}
case 'd': {
System.out.println("字母d");
break;
}
// default非必须
default: {
System.out.println("不是字母a、b、c、d");
}
}
}
}

字母a
进程已结束，退出代码为 0

需要注意的是，每个case分支代码块后应该以break结尾，否则会造成”case穿透“，也就会执行后续代码。这个有点反人类直觉，需要注意一下。比如：

public class Demo8 {
public static void main(String[] args) {
// 编写一个switch case结构，判断一个字符是否是字母a、b、c、d  
char ch = 'a';
switch (ch) {
case 'a': {
System.out.println("字母a");
// break;  
}
case 'b': {
System.out.println("字母b");
// break;  
}
case 'c': {
System.out.println("字母c");
// break;  
}
case 'd': {
System.out.println("字母d");
// break;  
}
default: {
System.out.println("不是字母a、b、c、d");
}
}
}
}

字母a
字母b
字母c
字母d
不是字母a、b、c、d
进程已结束，退出代码为 0

循环结构

Java中的循环结构有：while循环、do-while循环、for循环和数组for循环（增强型for循环）

while循环

while循环的结构是

while(布尔表达式) {
// 循环结构体
}

当布尔表达式结果为true时，执行{}内的代码块。

一般来说，while循环的布尔表达式初始时为true，在循环执行一定次数后，布尔表达式变为false，结束循环。如不结束结束循环，代码将一直执行，即死循环。

某些情况下如网络监听时，while循环的布尔表达式总为true，即：

while(true) {
// 一直循环，如网络监听。
}

while循环的示例代码如下，用循环计算1到100的总和：

public class Demo1 {
// 计算1~100的和  
public static void main(String[] args) {
int sum = 0;
int i = 1;
while(i <= 100) {
sum += i;
i++;
}
System.out.println(sum);
}
}

do-while循环

在while循环时，会先判断while后的布尔表达式是否为true，如果不满足，则不会执行{}内的代码块。

但是，很多时候，我们会要求循环代码至少执行一次，因此就诞生了do-while循环结构，如下：

do {
// 循环代码块
} while (布尔表达式)

由于程序遵循基本的顺序结构，会先执行{}代码块，然后判断while后的布尔表达式结果，若为true，则再次进入循环，执行{}代码块。若while后的布尔表达式为false，则不再循环，执行后续代码。

while循环和do-while循环，程序代码中的循环体、while后的布尔表达式都相同，唯一区别是do-while循环至少执行一次。比如：

public class Demo2 {
public static void main(String[] args) {
// while循环计算1~100的和  
int sum = 0;
int i = 1;
while(i <= 100) {
sum += i;
i++;
}
System.out.println(sum);
System.out.println("------------------");
//do ... while循环计算1~100的和  
sum = 0;
i = 1;
do {
sum += i;
i++;
} while(i <= 100);  // 布尔表达式与while循环时候一样
System.out.println(sum);
}
}

5050
------------------
5050
进程已结束，退出代码为 0

for循环

已经有while循环，为什么还要发明for循环？

我们在写while循环时，发现while循环总是有这么三个部分：初始化变量、循环判断布尔表达式、更新变量 这三个操作，比如：

public class Demo2 {
public static void main(String[] args) {
int sum = 0;
int i = 1;  // 初始化变量
while(i <= 100) {  // 循环判断布尔表达式
sum += i;  // 执行循环的代码
i++;  // 更新变量
}
System.out.println(sum);
}

为了提高编写循环代码的效率，发明了for循环，将初始化变量、循环判断布尔表达式、更新变量放在for循环括号内，而在{}代码块内专注于编写执行循环的代码体，如下：

public class Demo2 {
public static void main(String[] args) {
int sum = 0;
// for(初始化变量; 循环判断布尔表达式; 更新变量;)
for(int i = 1; i <= 100; i++) {
sum += i; // 执行循环的代码
}
System.out.println(sum);
}

因此，for循环的执行逻辑为：先执行初始化变量，再判断布尔表达式是否为true，若是则执行{} 后的代码，然后执行更新变量。然后再判断布尔表达式是否为true，若是则继续执行{}后的代码，然后更新变量。直到布尔表达式为false，则不再执行循环体，也不再更新变量。

增强型for循环

声明：仅做浅显理解。

如Python，Java也支持从数组/集合遍历的for循环，如下结构：

for(声明句子: 表达式) {
// 循环体
}

循环次数为数组的长度，每次循环获取一个数组的item，并赋值给声明的句子。示例：

public class Demo6 {
public static void main(String[] args) {
int[] a = {1, 2, 3, 4, 5};
for(int i: a) {
System.out.println(i);
}
}
}

1
2
3
4
5
进程已结束，退出代码为 0

break和continue

Java中有两个在循环中使用的关键字：break和continue。

break：用于退出循环，之后执行下一段代码。注意：是退出循环，而不是终止代码，需要继续按顺序执行循环结构下的其他代码。
continue：用于跳出当前循环，之后执行循环的布尔表达式的判断，若判断为true，则继续执行循环代码。注意：不是退出循环，需要执行下一个循环判断表达式。

比如：

public class Demo7 {
public static void main(String[] args) {
// 演示break功能退出循环。打印1~100之间第一个被5整除的数字  
int i = 1;
while(true) {
if(i % 5 == 0) {
System.out.println(i);
break;
}
i++;
}
System.out.println("循环结束：打印第一个被5整除的数字");
// 演示while循环中的continue功能，跳过当前循环，继续下一次循环。打印1~100之间除了被5整除的数字  
i = 1;
while(i <= 100) {
if (i % 5 == 0) {
i++;  // while循环中的continue需要放在变量更新操作后，否则会死循环  
continue;
}
System.out.println(i);
i++;
}
System.out.println("演示while循环中的continue功能，跳过当前循环，继续下一次循环。");
System.out.println("循环结束：打印除了被5整除的数字");
// 演示for循环中的continue功能，跳过当前循环，继续下一次循环。打印1~100之间除了被5整除的数字  
for(i = 1; i <= 100; i++) {
if(i % 5 == 0) {
continue; // for循环执行continue跳出循环后，会执行变量更新操作，再判断布尔表达式，满足则继续循环，不满足则结束循环  
}
System.out.println(i);
}
System.out.println("演示for循环中的continue功能，跳过当前循环，继续下一次循环。");
System.out.println("循环结束：打印除了被5整除的数字");
}
}

for循环和while/do-while循环的细节区别点：

while循环中的continue需要放在变量更新操作后，否则会死循环
for循环执行continue跳出循环后，会执行变量更新操作，再判断布尔表达式，满足则继续循环，不满足则结束循环

发表于 2026-01-06 22:18 jzssuanfa 阅读(15) 评论(0) 收藏举报

刷新页面返回顶部