一、什么是程序控制语句

程序默认是从上到下逐行执行的。控制语句的作用就是：改变代码执行顺序，实现判断、选择、重复、跳转，是所有算法、逻辑功能的基础。

Java 控制语句分为三大类：

1. 顺序结构（默认执行方式）
2. 分支结构（选择结构）：if、if-else、else if、switch
3. 循环结构：for、while、do-while
4. 跳转语句：break、continue、return

二、顺序结构（最基础）

特点

• 代码从上往下、依次执行
• 没有判断、没有跳转、没有重复

示例

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

所有代码默认都是顺序结构，其他语句都是在顺序结构上做“改变”。

三、分支选择结构（重点）

分支语句：满足条件才执行、不同条件执行不同代码。

下面是 if-else 分支结构的执行流程图，直观展示了不同分支的执行流程与控制流走向：

分支语句：满足条件才执行、不同条件执行不同代码。

1. if 单分支

语法

if(布尔条件){
    // 满足条件执行的代码
}

执行规则

• 条件为 true → 执行
• 条件为 false → 不执行

示例：判断是否成年

int age = 19;
if(age >= 18){
    System.out.println("已成年");
}

2. if-else 双分支（二选一）

语法

if(条件){
    // 成立执行
}else{
    // 不成立执行
}

一定执行其中一块，互斥！

示例

int score = 59;
if(score >= 60){
    System.out.println("及格");
}else{
    System.out.println("不及格");
}

3. else if 多分支（多选一）

适合多个区间判断。

语法

if(条件1){
    // ...
}else if(条件2){
    // ...
}else if(条件3){
    // ...
}else{
    // ...
}

规则

• 从上往下匹配
• 匹配成功一个，后面全部不执行

示例：成绩等级

int score = 88;
if(score >= 90){
    System.out.println("优秀");
}else if(score >= 80){
    System.out.println("良好");
}else if(score >= 60){
    System.out.println("及格");
}else{
    System.out.println("不及格");
}

4. switch 分支（固定值匹配）

适合：固定整数、字符、字符串匹配，不适合区间判断。

支持类型
byte、short、int、char、String、枚举

标准语法（带 break）

int num = 2;
switch(num){
    case 1:
        System.out.println("星期一");
        break;
    case 2:
        System.out.println("星期二");
        break;
    default:
        System.out.println("未知");
}

重点：穿透现象（考试必考）
不写 break 会穿透，继续执行下一个 case。

int n = 1;
switch(n){
    case 1:
        System.out.println("1");
    case 2:
        System.out.println("2");
    default:
        System.out.println("其他");
}

输出：

1
2
其他

开发中 switch 每个 case 必须加 break。

四、循环结构（核心重点）

循环作用：重复执行一段代码。

下面是 for/while/do-while 循环结构的执行流程图，直观展示了不同循环的执行流程与控制流走向：

Java 三种循环：

1. for（最常用、次数明确）
2. while（条件明确、次数不确定）
3. do-while（至少执行一次）

循环作用：重复执行一段代码。

Java 三种循环：

1. for（最常用、次数明确）
2. while（条件明确、次数不确定）
3. do-while（至少执行一次）

1. for 循环（万能循环）

语法

for(初始化; 条件判断; 更新){
    // 循环体
}

执行顺序：初始化 → 条件 true → 循环体 → 更新 → 条件……

示例：输出 1~10

for(int i = 1; i <= 10; i++){
    System.out.println(i);
}

死循环写法

for(;;){
    // ...
}

2. while 循环

语法

while(条件){
    // 循环体
}

特点：先判断，后执行，条件不成立一次都不执行。

示例：1~5 输出

int i = 1;
while(i <= 5){
    System.out.println(i);
    i++;
}

3. do-while 循环

语法

do{
    // 循环体
}while(条件);

特点：先执行一次，再判断，至少执行一次。

对比

• for：已知次数首选
• while：未知次数、先判断
• do-while：必须至少执行一次的场景

五、循环跳转语句 break、continue

1. break

作用：跳出当前循环 / 跳出 switch。

for(int i = 1; i <= 10; i++){
    if(i == 5){
        break; // 直接结束整个循环
    }
    System.out.println(i);
}

输出：1 2 3 4

2. continue

作用：跳过本次，继续下一次，不结束循环。

for(int i = 1; i <= 5; i++){
    if(i == 3){
        continue;
    }
    System.out.println(i);
}

输出：1 2 4 5

六、嵌套结构（考试、作业高频）

if 可以嵌套 if，循环可以嵌套循环。

嵌套 for 经典案例（九九乘法表结构）

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

完整九九乘法表 Java 程序

public class MultiplicationTable {
    public static void main(String[] args) {
        System.out.println("九九乘法表：");
        System.out.println("==============");
        
        // 外层循环控制行数（1-9）
        for (int i = 1; i <= 9; i++) {
            // 内层循环控制每行的列数（1-i）
            for (int j = 1; j <= i; j++) {
                // 格式化输出：j × i = 结果，使用制表符对齐
                System.out.print(j + "×" + i + "=" + (i * j) + "\t");
            }
            // 每行结束后换行
            System.out.println();
        }
    }
}

控制台输出结果：

九九乘法表：
==============
1×1=1	
1×2=2	2×2=4	
1×3=3	2×3=6	3×3=9	
1×4=4	2×4=8	3×4=12	4×4=16	
1×5=5	2×5=10	3×5=15	4×5=20	5×5=25	
1×6=6	2×6=12	3×6=18	4×6=24	5×6=30	6×6=36	
1×7=7	2×7=14	3×7=21	4×7=28	5×7=35	6×7=42	7×7=49	
1×8=8	2×8=16	3×8=24	4×8=32	5×8=40	6×8=48	7×8=56	8×8=64	
1×9=9	2×9=18	3×9=27	4×9=36	5×9=45	6×9=54	7×9=63	8×9=72	9×9=81	

程序说明：

三种循环嵌套使用对比

循环类型	特点	适用场景	注意事项
for 循环	1. 结构清晰：初始化、条件、更新三部分集中 2. 循环次数明确，易于控制嵌套层数 3. 循环变量作用域限定在循环内	1. 已知循环次数的嵌套（如九九乘法表、矩阵遍历） 2. 需要精确控制循环变量变化的场景 3. 多层嵌套时结构清晰易读	1. 注意循环变量的作用域，避免内外层变量名冲突 2. 嵌套层数不宜过多（一般不超过3层） 3. 更新表达式要正确，避免死循环
while 循环	1. 条件判断在前，可能一次都不执行 2. 适合条件复杂、循环次数不确定的场景 3. 循环变量需要在循环外声明和更新	1. 条件依赖外部状态变化的嵌套（如文件读取、游戏循环） 2. 需要根据运行时条件动态决定是否继续嵌套循环 3. 事件驱动型嵌套处理	1. 务必在循环体内更新条件变量，否则可能死循环 2. 嵌套时条件判断要清晰，避免逻辑混乱 3. 注意条件变量的作用域和生命周期
do-while 循环	1. 先执行一次循环体，再判断条件 2. 至少执行一次，适合必须先执行再判断的场景 3. 条件判断在后，与while相反	1. 需要至少执行一次的菜单选择系统 2. 用户输入验证的嵌套处理 3. 必须先执行初始化再判断的嵌套场景	1. 注意结尾的分号不能省略 2. 嵌套时内层循环的条件可能依赖外层执行结果 3. 确保循环体至少执行一次是必要的

嵌套循环通用建议：

1. 变量命名：内外层循环变量使用不同名称（如 i、j、k）

2. 性能优化：尽量减少嵌套层数，时间复杂度随嵌套层数指数增长

3. 代码可读性：适当添加注释，说明每层循环的作用

4. 边界检查：确保每层循环的终止条件正确，避免数组越界

5. 外层循环：for (int i = 1; i <= 9; i++) 控制乘法表的行数（1-9）

6. 内层循环：for (int j = 1; j <= i; j++) 控制每行的列数，列数等于当前行数

7. 输出格式：使用 \t（制表符）对齐，使乘法表排列整齐

8. 算法核心：i * j 计算乘积，j + "×" + i + "=" + (i * j) 格式化输出

这个程序可以直接复制到 Java IDE 中运行，展示了嵌套 for 循环的经典应用。

七、所有控制语句核心总结（背诵版）

1. 顺序结构：从上到下默认执行
2. 分支结构
   • if：适合区间、范围判断
   • switch：适合固定值匹配，必须注意 break 穿透
3. 循环结构
   • for：次数确定，最常用
   • while：先判断后执行
   • do-while：先执行后判断，至少一次
4. 跳转
   • break：结束整个循环
   • continue：结束本次循环

八、常见易错点（大一必踩坑）

1. if 后面不要随便加分号 if(); 会直接空执行
2. 循环内忘记 i++ → 死循环
3. switch 不写 break → 穿透错误
4. continue、break 只能控制当前所在最近一层循环
5. do-while 最后必须有分号