Java 控制结构详解：从基础到进阶，轻松掌握编程核心逻辑

系列文章目录

01-从入门到精通：Java 基础语法全解析，快速掌握核心编程技能
02-Java 控制结构详解：从基础到进阶，轻松掌握编程核心逻辑

---

---

前言

在编程的世界里，控制程序逻辑的能力至关重要。控制结构正是实现这一能力的关键工具，它决定了程序执行的流程和行为。无论是条件判断还是循环操作，控制结构都是编写高效、灵活程序的核心组成部分。

Java 提供了一套强大的控制结构，包括条件语句（if-else 和 switch）、循环结构（for、while、do-while），以及循环控制语句（break 和 continue）。这些工具不仅能帮助开发者解决复杂的逻辑问题，还能优化程序性能，提升代码的可读性。

---

一、条件语句：if-else 与 switch

在 Java 中，条件语句是用来控制程序执行逻辑的重要工具。通过条件语句，程序可以根据特定条件的真假选择不同的执行路径。Java 提供了两种常见的条件控制结构：if-else 和 switch，它们适用于不同场景。

---

1.1 if-else 条件语句

if-else 是 Java 中最基本的条件语句，能够根据条件的真假执行不同的代码块。

1.1.1 基本语法

if (条件) {
    // 当条件为 true 时执行的代码
} else {
    // 当条件为 false 时执行的代码
}

1.1.2 示例：简单的 if-else 语句

以下代码通过判断用户的年龄来决定输出的信息：

int age = 20;
if (age >= 18) {
    System.out.println("您是成年人。");
} else {
    System.out.println("您未成年。");
}

执行逻辑：

• 当 age >= 18 时，输出 “您是成年人。”。
• 否则，输出 “您未成年。”。

---

1.1.3 多重 if-else 语句

当需要检查多个条件时，可以使用多重 if-else 语句：

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

执行逻辑：

1. 如果 score >= 90，输出 “优秀”。
2. 如果 score >= 75 且小于 90，输出 “良好”。
3. 如果 score >= 60 且小于 75，输出 “及格”。
4. 如果 score < 60，输出 “不及格”。

---

1.1.4 嵌套 if 语句

在某些情况下，可以将一个 if-else 嵌套在另一个 if 语句中：

int age = 20;
boolean hasLicense = true;

if (age >= 18) {
    if (hasLicense) {
        System.out.println("您可以开车。");
    } else {
        System.out.println("您需要先考取驾照。");
    }
} else {
    System.out.println("您未满 18 岁，不能开车。");
}

执行逻辑：

1. 如果 age >= 18，进入内层 if 检查是否有驾照。
2. 如果 hasLicense == true，输出 “您可以开车。”。
3. 如果没有驾照，输出 “您需要先考取驾照。”。

---

1.1.5 注意事项

1. 条件必须为布尔表达式：条件只能返回 true 或 false，例如：

   if (x > 0) {
       System.out.println("正数");
   }
   

   像 if (x) 这种写法在 Java 中是非法的（不同于某些其他语言）。
2. 注意语句块：如果 if 或 else 后只有一条语句，可以省略大括号 {}，但推荐始终使用 {} 提高代码可读性。

---

1.2 switch 条件语句

switch 语句用于针对单个变量的多个值进行判断，与多重 if-else 相比，代码更加简洁清晰。

1.2.1 基本语法

switch (变量) {
    case 值1:
        // 当变量等于值1时执行的代码
        break;
    case 值2:
        // 当变量等于值2时执行的代码
        break;
    default:
        // 当变量不匹配任何值时执行的代码
}

1.2.2 示例：根据星期几输出安排

int day = 3; // 假设 1 表示周一，2 表示周二，依此类推
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;
    default:
        System.out.println("周末休息！");
}

1.2.3 使用字符串的 switch

Java 7 及以上版本支持在 switch 中使用字符串：

String season = "Spring";
switch (season) {
    case "Spring":
        System.out.println("春天来了！");
        break;
    case "Summer":
        System.out.println("夏天来了！");
        break;
    case "Fall":
        System.out.println("秋天来了！");
        break;
    case "Winter":
        System.out.println("冬天来了！");
        break;
    default:
        System.out.println("未知的季节！");
}

---

1.2.4 注意事项

1. 避免忘记 break：
   • 如果 case 中没有 break，程序会继续执行下一个 case 的代码，即“贯穿现象”：

     int num = 2;
     switch (num) {
         case 1:
             System.out.println("一");
         case 2:
             System.out.println("二");
         case 3:
             System.out.println("三");
     }
     // 输出：二 三
     

     在多数场景下，这种行为并非预期，所以要记得加上 break。
2. default 是可选的：
   • 如果不需要处理变量不匹配任何 case 的情况，可以省略 default，但通常建议加上 default 作为兜底逻辑。

---

1.2.5 switch 与 if-else 的选择

场景	建议使用
条件是多个明确值时	使用 switch
条件是范围或复杂逻辑时	使用 if-else
条件变量是字符串（Java 7+ 支持）	使用 switch
条件变量是布尔值	使用 if-else

---

1.2.6 示例：switch 与 if-else 对比

使用 if-else：

int day = 3;
if (day == 1) {
    System.out.println("今天是星期一");
} else if (day == 2) {
    System.out.println("今天是星期二");
} else if (day == 3) {
    System.out.println("今天是星期三");
} else {
    System.out.println("周末休息！");
}

使用 switch：

switch (day) {
    case 1:
        System.out.println("今天是星期一");
        break;
    case 2:
        System.out.println("今天是星期二");
        break;
    case 3:
        System.out.println("今天是星期三");
        break;
    default:
        System.out.println("周末休息！");
}

switch 更加清晰、简洁，便于阅读和维护。

---

二、循环结构：for、while 与 do-while

在程序设计中，循环结构是实现重复性任务的核心。通过循环，开发者可以让代码在满足一定条件时重复执行，极大地提高程序的效率。Java 提供了三种基本的循环结构：for、while 和 do-while，它们适用于不同的应用场景。

---

2.1 for 循环

for 循环用于明确知道循环次数的场景。它的循环条件、初始化语句、迭代语句均可以在一行内完成，方便简洁。

2.1.1 基本语法

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

• 初始化：在循环开始前执行一次的代码块（通常是变量的初始化）。
• 条件：每次迭代前进行条件检查，只有条件为 true 时，循环体才会执行。
• 更新：每次迭代后执行的代码（通常是控制变量的更新）。

---

2.1.2 示例：打印 1 到 10 的数字

for (int i = 1; i <= 10; i++) {
    System.out.println("当前数字：" + i);
}

执行过程：

1. 初始化：int i = 1，控制变量 i 初始化为 1。
2. 条件检查：判断 i <= 10 是否为 true。
3. 执行循环体：输出当前数字。
4. 更新：i++，将 i 的值加 1。
5. 重复步骤 2-4，直到条件为 false。

---

2.1.3 嵌套 for 循环

for 循环可以嵌套使用，用于处理多维结构，例如打印矩阵。

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

输出结果：

1 2 3 
2 4 6 
3 6 9

---

2.1.4 特殊情况

1. 空循环：

   for (int i = 0; i < 5; i++); // 循环体为空
   

2. 无限循环：

   for (;;) {
       System.out.println("无限循环");
   }
   

   • 条件省略，意味着永远为 true，适用于特定需求。

---

2.2 while 循环

while 循环的特点是先判断条件，再执行循环体。它适用于条件未知但有明确退出条件的场景。

---

2.2.1 基本语法

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

• 条件：每次迭代前检查的布尔表达式，条件为 true 则执行循环体。
• 循环体：条件为 true 时重复执行的代码块。

---

2.2.2 示例：计算小于 100 的累加和

int sum = 0;
int i = 1;
while (i < 100) {
    sum += i; // 将 i 加入 sum
    i++; // 控制变量 i 自增
}
System.out.println("累加和：" + sum);

执行过程：

1. 初始化 i = 1，sum = 0。
2. 条件检查：i < 100 是否为 true。
3. 执行循环体：sum 加上 i 的值，i 自增。
4. 重复步骤 2-3，直到条件为 false。

---

2.2.3 无限循环

与 for 循环类似，可以省略条件形成无限循环：

while (true) {
    System.out.println("无限循环");
}

在实际应用中，通常配合 break 控制退出。

---

2.3 do-while 循环

do-while 循环与 while 循环类似，不同之处在于它先执行循环体，再判断条件。无论条件是否为 true，循环体至少会执行一次。

---

2.3.1 基本语法

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

• 循环体：无条件执行一次，然后根据条件决定是否继续执行。
• 条件：每次迭代后检查的布尔表达式。

---

2.3.2 示例：获取用户输入

import java.util.Scanner;

Scanner scanner = new Scanner(System.in);
int number;

do {
    System.out.print("请输入一个正数：");
    number = scanner.nextInt();
} while (number <= 0);

System.out.println("您输入的正数是：" + number);

执行过程：

1. 第一次执行循环体，提示用户输入。
2. 检查条件 number <= 0 是否为 true。
3. 条件为 true 时继续重复输入操作，直到条件为 false。

---

2.3.3 示例：打印 1 到 10 的数字

int i = 1;
do {
    System.out.println("当前数字：" + i);
    i++;
} while (i <= 10);

---

2.4 for、while 与 do-while 的对比

特点	for	while	do-while
适用场景	确定循环次数	条件未知但有退出条件	至少执行一次的场景
条件检查	每次迭代前检查	每次迭代前检查	每次迭代后检查
执行次数	条件不满足时一次也不执行	条件不满足时一次也不执行	至少执行一次
语法简洁性	最适合结构化、计数型循环	适合不确定的条件型循环	用于特殊的逻辑需求

---

2.5 循环嵌套与实际应用

在实际开发中，循环结构经常嵌套使用，用于处理二维或多维问题。例如：

示例：打印九九乘法表

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();
}

输出结果：

1 * 1 = 1	
2 * 1 = 2	2 * 2 = 4	
3 * 1 = 3	3 * 2 = 6	3 * 3 = 9
...

---

三、循环控制语句：break 与 continue

在 Java 的循环结构中，break 和 continue 是两种常用的控制语句，用于控制循环的执行流程。它们可以改变循环的正常执行顺序，从而实现更灵活的程序逻辑。

---

3.1 break 语句

break 用于立即跳出当前循环，无论循环条件是否已经满足。通常在某些特定条件下，用于提前结束循环。

3.1.1 基本语法

break;

3.1.2 示例：找到第一个大于 50 的数字

以下代码演示如何在遍历 1 到 100 的数字时，找到第一个大于 50 的数字并结束循环。

for (int i = 1; i <= 100; i++) {
    if (i > 50) {
        System.out.println("找到的数字是：" + i);
        break; // 跳出循环
    }
}

执行过程：

1. 遍历数字 i 从 1 到 100。
2. 当 i > 50 时，条件满足，输出数字。
3. 执行 break，立即退出循环。

---

3.1.3 break 用于嵌套循环

在嵌套循环中，break 只会跳出所在的内层循环：

for (int i = 1; i <= 3; i++) {
    for (int j = 1; j <= 3; j++) {
        if (j == 2) {
            break; // 跳出内层循环
        }
        System.out.println("i=" + i + ", j=" + j);
    }
}

输出结果：

i=1, j=1
i=2, j=1
i=3, j=1

---

3.2 continue 语句

continue 用于跳过当前循环的剩余代码，直接开始下一次循环。与 break 不同，continue 并不会结束整个循环。

3.2.1 基本语法

continue;

3.2.2 示例：打印 1 到 10 的奇数

以下代码通过 continue 跳过偶数的输出。

for (int i = 1; i <= 10; i++) {
    if (i % 2 == 0) {
        continue; // 跳过偶数
    }
    System.out.println("奇数：" + i);
}

执行过程：

1. 遍历 i 从 1 到 10。
2. 当 i % 2 == 0 时，执行 continue 跳过当前循环体的剩余代码，直接进入下一次循环。
3. 只有奇数会被打印。

---

3.2.3 continue 用于嵌套循环

与 break 类似，continue 也只影响所在的内层循环。

for (int i = 1; i <= 3; i++) {
    for (int j = 1; j <= 3; j++) {
        if (j == 2) {
            continue; // 跳过 j=2
        }
        System.out.println("i=" + i + ", j=" + j);
    }
}

输出结果：

i=1, j=1
i=1, j=3
i=2, j=1
i=2, j=3
i=3, j=1
i=3, j=3

---

3.3 break 与 continue 的对比

特性	break	continue
作用	跳出整个循环，结束当前循环的执行	跳过当前循环的剩余代码，进入下一次循环
适用场景	提前结束循环	跳过不需要的循环迭代
影响范围	仅作用于所在的循环或 switch 结构	仅作用于所在的循环

---

四、Java 中的增强 for 循环与应用场景

增强 for 循环（也称为 “for-each” 循环）是 Java 在遍历集合或数组时的一种简化写法。相比传统 for 循环，它更简洁，代码可读性更强。

---

4.1 增强 for 循环的基本语法

for (数据类型 变量 : 集合或数组) {
    // 循环体
}

• 集合或数组：指需要被遍历的数据结构，例如数组、List、Set 等。
• 变量：每次循环时，依次获取集合或数组中的元素。

---

4.2 示例：遍历数组

以下代码展示如何使用增强 for 循环遍历一个整数数组：

int[] numbers = {10, 20, 30, 40};
for (int number : numbers) {
    System.out.println("数组元素：" + number);
}

执行过程：

1. 每次循环，number 依次被赋值为数组中的每个元素。
2. 依次输出数组的值。

---

4.3 示例：遍历集合

增强 for 循环可以用于遍历 Java 集合，例如 List：

import java.util.ArrayList;

public class EnhancedForExample {
    public static void main(String[] args) {
        ArrayList<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");

        for (String name : names) {
            System.out.println("姓名：" + name);
        }
    }
}

---

4.4 增强 for 循环的应用场景

4.4.1 遍历数组

增强 for 循环可以快速遍历数组元素，但无法修改数组元素值。例如：

int[] numbers = {1, 2, 3, 4};
for (int number : numbers) {
    System.out.println("当前元素：" + number);
}

4.4.2 遍历集合

在处理 List、Set 或 Map 时，增强 for 循环特别适合只读操作：

List<Integer> numbers = Arrays.asList(10, 20, 30);
for (int number : numbers) {
    System.out.println("集合中的元素：" + number);
}

---

4.5 注意事项

1. 增强 for 循环不支持下标访问：

   • 如果需要访问元素的索引，必须使用传统的 for 循环：

     int[] numbers = {10, 20, 30};
     for (int i = 0; i < numbers.length; i++) {
         System.out.println("索引 " + i + " 的值是：" + numbers[i]);
     }
     

2. 无法修改数组或集合中的元素：

   • 增强 for 循环中的变量是一个副本，修改它不会影响原始数组或集合。

     int[] numbers = {10, 20, 30};
     for (int number : numbers) {
         number += 5; // 无法修改原始数组
     }
     System.out.println(Arrays.toString(numbers)); // 输出：[10, 20, 30]
     

3. 适用于只读操作：

   • 如果需要修改集合中的元素，建议使用传统 for 循环或迭代器。

---

五、总结

1. 条件语句（if-else 与 switch）：

   • 使用 if-else 处理范围或复杂逻辑，适合精细化的条件判断。
   • 使用 switch 简化多值分支选择，适合处理明确的固定值。

2. 循环结构（for、while 与 do-while）：

   • for 循环适用于已知循环次数的场景，语法紧凑，易读易写。
   • while 循环用于条件未知但有明确退出条件的场景。
   • do-while 循环保证循环体至少执行一次，适合特定逻辑需求。

3. 循环控制语句（break 与 continue）：

   • break 用于提前终止循环，适合找到目标后直接退出的场景。
   • continue 跳过当前循环的剩余部分，直接进入下一次迭代。

4. 增强 for 循环：

   • 增强 for 循环专为遍历数组和集合而设计，简化代码，提高可读性。
   • 适用于只读操作，不适合需要修改原始数据的场景。

---