一、概述：三大流程控制结构

Java 程序的执行流程由三种基本结构组成：顺序结构、分支结构和循环结构。

结构	核心特点	典型场景
顺序结构	代码按书写顺序从上到下依次执行，无跳转	变量赋值、连续输出、固定流程
分支结构	根据条件选择一条路径执行	条件判断、多分支选择
循环结构	重复执行某段代码，满足条件后停止	批量处理、遍历数据

---

二、顺序结构

2.1 定义

顺序结构是程序最基础的执行结构，代码按照书写先后顺序，从上到下依次执行。所有程序默认采用顺序结构。

2.2 核心特点

• 执行路径唯一，不会跳过或重复某段代码
• 先写的代码先执行，后写的后执行
• 分支结构和循环结构内部的代码也是顺序执行的

2.3 代码示例

public class Test {
    public static void main(String[] args) {
        System.out.println("努力做主人喜欢的事");
        System.out.println("大小姐驾到！统统闪开！");
        System.out.println("凛冬已至，故乡的梅花开了吗");
        System.out.println("心怀不惧，方能翱翔于天际");
    }
}

4 行输出按代码书写顺序依次打印，不会乱序。

---

三、分支结构

分支结构根据条件表达式的布尔值，选择一条执行路径。

3.1 if 分支（第一种格式）

语法结构

if (关系表达式) {
    语句体;
}

执行逻辑

1. 计算关系表达式的值
2. 若为 true，执行语句体
3. 若为 false，跳过语句体

代码示例

public class IfDemo {
    public static void main(String[] args) {
        boolean flag = true;
        if (flag) {
            System.out.println("flag的值为true");
        }

        int number = 20;
        if (number >= 10) {
            int a = 100;
            System.out.println("number大于等于10");
        }
    }
}

注意事项

规范项	推荐写法	不推荐写法
大括号位置	if (flag) { 接在条件后	大括号另起一行
大括号省略	始终保留大括号	if (flag) System.out.println(...);
布尔变量判断	if (flag)	if (flag == true)

• 语句体只有一行代码时，大括号可省略，但不建议省略（后续添加代码时容易逻辑出错）
• 对 boolean 类型变量判断，直接用变量名，不使用 == true / == false

---

3.2 if-else 分支（第二种格式）

语法结构

if (关系表达式) {
    语句体1;
} else {
    语句体2;
}

执行逻辑

1. 计算关系表达式的布尔值
2. 若为 true，执行语句体1
3. 若为 false，执行语句体2
4. 语句体1和语句体2必有且仅有一个被执行

代码示例

public class IfElseDemo {
    public static void main(String[] args) {
        // 判断奇偶
        int num = 7;
        if (num % 2 == 0) {
            System.out.println(num + "是偶数");
        } else {
            System.out.println(num + "是奇数");   // 执行此分支
        }

        // 判断及格
        int score = 85;
        if (score >= 60) {
            System.out.println("考试及格");        // 执行此分支
        } else {
            System.out.println("考试不及格");
        }
    }
}

输出：

7是奇数
考试及格

三种 if 格式对比

格式类型	适用场景	分支数量
if（第一种）	单条件场景	1 个分支
if-else（第二种）	二选一场景	2 个分支
if-else if-else（第三种）	多选一场景	3 个及以上分支

---

3.3 if-else if-else 分支（第三种格式）

语法结构

if (关系表达式1) {
    语句体1;
} else if (关系表达式2) {
    语句体2;
} else {
    语句体n;
}

执行逻辑

1. 依次判断关系表达式1、2...的布尔值
2. 若某个表达式为 true，执行对应语句体，后续分支不再判断
3. 若所有表达式均为 false，执行 else 对应的语句体
4. 最终仅有一个语句体被执行

代码示例

public class IfElseIfDemo {
    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("成绩等级：不及格");
        }
    }
}

注意事项

• 分支顺序：条件范围应从大到小或从特殊到一般排列，否则会导致逻辑错误

// 错误：先判断 >=60，后续 >=80 的条件永远不会命中
if (score >= 60) { ... }
else if (score >= 80) { ... }

// 正确：从高到低排列
if (score >= 90) { ... }
else if (score >= 80) { ... }

• else 分支可省略，但省略后若所有条件不满足则无任何输出

---

3.4 switch 语句

语法结构

switch (表达式) {
    case 常量值1:
        语句体1;
        break;
    case 常量值2:
        语句体2;
        break;
    default:
        语句体n;
        break;
}

核心规则

规则项	说明
表达式类型	byte / short / int / char / String（JDK7+）/ 枚举
case 常量值	必须唯一，不可重复
break	执行完对应分支后跳出 switch，省略会触发case 穿透
default	所有 case 不匹配时执行，可放在任意位置（习惯放在最后）

代码示例

示例1：基础用法

int num = 7;
switch (num) {
    case 1:
        System.out.println("匹配到1");
        break;
    case 7:
        System.out.println("匹配到7");   // 执行此分支
        break;
    default:
        System.out.println("未匹配");
        break;
}

示例2：case 穿透（合理用法）

int month = 3;
switch (month) {
    case 3:
    case 4:
    case 5:
        System.out.println("春季");   // 3/4/5 月均执行
        break;
    case 6:
    case 7:
    case 8:
        System.out.println("夏季");
        break;
}

示例3：JDK 14+ switch 表达式

int number = 1;
String result = switch (number) {
    case 1 -> "匹配到1";
    case 2 -> "匹配到2";
    default -> "未匹配";
};
System.out.println(result);

// 多行语句体使用 yield 返回值
String multi = switch (number) {
    case 1 -> {
        System.out.println("执行多行逻辑");
        yield "匹配到1";
    }
    default -> "未匹配";
};

switch 与 if-else if 对比

特性	switch	if-else if
适用场景	多条件等值匹配	多条件范围/等值匹配
可读性	等值匹配时更简洁	范围匹配时更灵活
条件类型	int / String 等有限类型	任意布尔表达式

常见错误

错误	原因	解决
Duplicate branch in 'switch'	存在重复的 case 常量值	确保每个 case 值唯一
类型不匹配	case 常量值与表达式类型不一致	统一两者类型
case 穿透导致逻辑错误	省略了必要的 break	在需要结束的分支后添加 break

---

四、循环结构

4.1 for 循环

语法结构

for (初始化表达式; 条件判断表达式; 递增/递减表达式) {
    // 循环体
}

• 初始化表达式：循环开始前执行一次（定义循环变量）
• 条件判断表达式：每次循环前判断，true 则执行循环体，false 则结束
• 递增/递减表达式：每次循环体执行后执行

代码示例

// 打印 1~5
for (int i = 1; i <= 5; i++) {
    System.out.println("当前数字：" + i);
}

增强 for 循环（foreach，JDK 5+）

String[] fruits = {"苹果", "香蕉", "橙子"};
for (String fruit : fruits) {
    System.out.println("水果：" + fruit);
}

注意事项

• 循环变量的作用域仅在 for 循环体内
• 增强 for 循环无法修改数组/集合的元素（仅能读取）
• 三个表达式均可省略，for(;;) 为无限循环（需手动 break）

---

4.2 while 循环

语法结构

初始化语句;
while (布尔条件表达式) {
    循环体语句;
    迭代语句;
}

执行逻辑

1. 执行初始化语句
2. 判断条件表达式：true → 执行循环体 → 执行迭代 → 再次判断；false → 终止循环
3. 循环体可能一次都不执行

代码示例

int i = 1;
while (i <= 5) {
    System.out.println(i);
    i++;
}
// 输出：1 2 3 4 5

---

4.3 do-while 循环

语法结构

初始化语句;
do {
    循环体语句;
    迭代语句;
} while (布尔条件表达式);   // 末尾必须加分号

执行逻辑

1. 执行初始化语句
2. 先执行循环体 → 执行迭代 → 判断条件
3. 循环体至少执行一次（唯一区别于 while 的点）

代码示例

// 条件不满足仍执行一次
int i = 6;
do {
    System.out.println(i);   // 输出：6
    i++;
} while (i <= 5);

while vs do-while 对比

特性	while	do-while
执行顺序	先判断，后执行	先执行，后判断
最少执行次数	0 次	1 次
语法结尾	无需分号	必须加分号
适用场景	不确定是否需执行循环	至少需执行一次循环

核心避坑

问题	原因	解决
无限循环（死循环）	迭代语句缺失，条件永远为 true	确保迭代语句让条件最终为 false
do-while 漏分号	末尾缺少 ;	while (条件);
循环变量作用域混淆	变量在循环内部定义	注意变量定义位置与作用范围

---

4.4 无限循环

无限循环指循环条件永远为 true，需手动终止（break / return / 异常 / 外部标志位），否则程序永久运行。

三种写法

写法	可读性	使用频率
while (true) { ... }	最高	最常用
do { ... } while (true);	中等	至少执行一次时使用
for (;;) { ... }	最低	极简写法

示例：while(true) + break

import java.util.Scanner;

public class MenuDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("===== 菜单 =====");
            System.out.println("1. 查看信息");
            System.out.println("0. 退出程序");
            System.out.print("请输入指令：");
            int choice = sc.nextInt();

            if (choice == 0) {
                System.out.println("程序退出");
                break;   // 手动终止无限循环
            }

            switch (choice) {
                case 1:
                    System.out.println("用户ID=1001");
                    break;
                default:
                    System.out.println("无效指令");
            }
        }
        sc.close();
    }
}

终止方式

方式	语法	效果
break	break;	终止当前循环
return	return; / return 值;	结束整个方法，连带终止循环
标志位	volatile boolean flag	多线程中外部控制终止

注意事项

• 必须包含终止逻辑（if + break），否则为纯死循环
• 终止条件必须可达，避免"永不满足"的终止判断
• do-while 末尾必须加分号
• 多线程中标志位需加 volatile 保证可见性

---

五、跳转控制语句

跳转控制语句用于改变程序执行流程，Java 中常用 break、continue、return 三种。

5.1 break 语句

定义

强制终止当前所在的循环或 switch 语句，跳出到语句块外部继续执行。

使用场景

场景1：终止循环

// 找到第一个能被3整除的数后终止
for (int i = 1; i <= 10; i++) {
    if (i % 3 == 0) {
        System.out.println("找到：" + i);
        break;   // 终止 for 循环
    }
    System.out.println("当前数字：" + i);
}
// 输出：当前数字：1  当前数字：2  找到：3

场景2：终止 switch（避免穿透）

switch (choice) {
    case 1:
        System.out.println("选择了1");
        break;   // 终止 switch
    case 2:
        System.out.println("选择了2");
        break;
}

场景3：带标签终止外层循环

outer:
for (int i = 1; i <= 3; i++) {
    for (int j = 1; j <= 3; j++) {
        if (j == 2) {
            break outer;   // 终止 outer 标记的外层循环
        }
        System.out.println("i=" + i + ", j=" + j);
    }
}
// 输出：i=1, j=1

---

5.2 continue 语句

定义

跳过当前循环的剩余代码，直接进入下一次循环的条件判断（不终止循环）。

代码示例

// 跳过偶数，只打印奇数
for (int i = 1; i <= 5; i++) {
    if (i % 2 == 0) {
        continue;   // 跳过本次剩余代码
    }
    System.out.println("奇数：" + i);
}
// 输出：奇数：1  奇数：3  奇数：5

带标签跳过外层循环

outer:
for (int i = 1; i <= 3; i++) {
    for (int j = 1; j <= 3; j++) {
        if (j == 2) {
            continue outer;   // 跳过外层本次循环
        }
        System.out.println("i=" + i + ", j=" + j);
    }
}
// 输出：i=1,j=1  i=2,j=1  i=3,j=1

---

5.3 return 语句

定义

结束当前方法，并可选择返回一个值。return 之后的方法内代码不可达。

使用场景

场景1：返回值并结束方法

public static int add(int a, int b) {
    return a + b;   // 返回结果，结束方法
}

场景2：void 方法中提前终止

public static void checkAge(int age) {
    if (age < 18) {
        System.out.println("未满18岁，无法操作");
        return;   // 提前结束方法
    }
    System.out.println("已成年，操作成功");
}

场景3：循环中用 return 结束方法

public static void findTarget(int[] arr, int target) {
    for (int num : arr) {
        if (num == target) {
            System.out.println("找到目标数：" + target);
            return;   // 结束方法，循环连带终止
        }
    }
    System.out.println("未找到目标数");
}

---

5.4 三大跳转语句对比

语句	作用范围	核心效果	适用场景
break	当前循环/switch	终止当前语句块	提前终止循环、避免 switch 穿透
continue	当前循环	跳过本次，进入下一次	过滤循环中特定条件
return	当前方法	结束方法，可返回值	返回结果、提前结束方法

5.5 break 与 return 核心区别

维度	break	return
作用范围	当前循环/switch 语句块	整个方法
对后续代码的影响	方法内循环外的代码继续执行	循环外的代码不再执行
能否返回值	否	是（非void方法）

// break：循环外代码仍执行
for (int i = 1; i <= 5; i++) {
    if (i == 3) break;
    System.out.println("i=" + i);
}
System.out.println("break后，方法仍在执行");   // 会执行

// return：循环外代码不执行
for (int i = 1; i <= 5; i++) {
    if (i == 3) return;
    System.out.println("i=" + i);
}
System.out.println("这行不会执行");   // 不会执行

---

六、综合示例：三种结构联用

public class FlowControlDemo {
    public static void main(String[] args) {
        // 循环结构：重复5天
        for (int day = 1; day <= 5; day++) {
            System.out.println("第" + day + "天放学了");

            // 顺序结构：按顺序执行
            System.out.println("开门");
            System.out.println("放下书包");

            // 分支结构：判断条件
            boolean hasHomework = true;
            if (hasHomework) {
                System.out.println("写作业");
            } else {
                System.out.println("看动画片");
            }

            System.out.println("----------");
        }
    }
}