关注公众号
原创
第三篇：Java之旅：掌控程序流程 - 分支、循环与跳转

1. 程序流程的基础：顺序结构

在深入学习复杂的控制逻辑之前，我们必须首先明确最基本的一种流程——顺序结构。这其实是我们自编写第一个"Hello, World!"程序以来就一直在使用的结构。顺序结构的核心思想非常简单：程序代码严格按照其书写顺序，从上到下、从左到右，逐行执行，期间不会有任何跳跃或重复。它是任何程序默认的、最自然的执行流程。

我们可以将其比作一本食谱，你必须严格按照步骤一、步骤二、步骤三的顺序来操作，才能最终做出美味的佳肴。

public class SequentialExecution {
    public static void main(String[] args) {
        // 第一步：声明并初始化变量
        String name = "张三";
        int year = 2025;
        
        // 第二步：进行简单的计算
        int age = year - 1998;
        
        // 第三步：打印信息到控制台
        System.out.println("程序开始执行...");
        System.out.println("姓名: " + name);
        System.out.println("年龄: " + age);
        
        // 第四步：打印结束信息
        System.out.println("程序顺序执行完毕。");
    }
}

上面这段代码的执行顺序是固定且唯一的，它完美地诠释了顺序结构。然而，现实世界的逻辑远比这复杂，充满了各种“如果...那么...”的选择和“日复一日”的重复。因此，我们需要更强大的流程控制工具。

2. 人生的岔路口：分支结构 (Selection Structures)

分支结构，也常被称为选择结构或条件结构，它赋予了程序“决策”的能力。程序可以根据一个或多个条件是否成立，来决定接下来要执行哪一段特定的代码块。这就像我们站在一个十字路口，需要根据红绿灯（条件）的状态来决定是“前进”还是“等待”。Java主要提供了if系列语句和switch语句来实现这一功能。

2.1 if 语句：单一条件的判断

这是最基础的分支结构，用于处理“如果某个条件满足，就执行某项任务”的场景。

语法格式：

if (布尔表达式) {
    // 语句块：如果布尔表达式的结果为 true，则执行这里的代码
}
// 程序继续向下执行...
  • 布尔表达式：这是一个结果必须为boolean类型（true或false）的表达式。它通常由我们上一章学习的比较运算符（>, <, ==等）和逻辑运算符（&&, ||, !等）构成。
  • 代码块：如果花括号{}内只有一条执行语句，那么花括号可以省略。但是，为了代码的清晰度和未来的可维护性，强烈建议无论代码多少，都不要省略花括号。

示例：检查用户是否为VIP

boolean isVip = true;
if (isVip) {
    System.out.println("尊敬的VIP用户，您好！");
    System.out.println("您将享有专属折扣。");
}

2.2 if-else 语句：非此即彼的抉择

这个结构为程序提供了两条路径，用于处理“如果条件满足，就做A；否则，就做B”的互斥选择场景。

语法格式：

if (布尔表达式) {
    // 语句块A：如果布尔表达式为 true，执行这里
} else {
    // 语句块B：如果布尔表达式为 false，执行这里
}

if和else中的代码块永远只有一个会被执行。

示例：判断一个整数是奇数还是偶数

int number = 7;
if (number % 2 == 0) {
    System.out.println(number + " 是一个偶数。");
} else {
    System.out.println(number + " 是一个奇数。");
}

2.3 if-else if-else 语句：多重路径的选择

当我们需要在一系列互斥的条件中进行选择时，可以使用这个链式结构。程序会从上到下逐个检查if和else if的条件。一旦遇到第一个为true的条件，就会执行其对应的代码块，然后整个if-else if-else结构立即结束，后续的条件将不再被检查。

语法格式：

if (布尔表达式1) {
    // 语句块1
} else if (布尔表达式2) {
    // 语句块2
} else if (布尔表达式3) {
    // 语句块3
}
...
else { // 可选的
    // 语句块N：如果以上所有条件都不满足，则执行这里
}

示例：根据气温提供穿衣建议

int temperature = 18; // 摄氏度
if (temperature > 28) {
    System.out.println("天气炎热，建议穿短袖。");
} else if (temperature > 15) {
    System.out.println("天气温和，建议穿长袖T恤或薄外套。");
} else if (temperature > 5) {
    System.out.println("天气较冷，建议穿毛衣或夹克。");
} else {
    System.out.println("天气寒冷，建议穿羽绒服保暖。");
}
// 输出: 天气温和，建议穿长袖T恤或薄外套。

2.4 switch 语句：定值判断的高效选择

当分支的条件是判断一个变量是否等于某些特定的、离散的常量值时，switch语句是一种比if-else if更清晰、在某些情况下（底层实现优化）更高效的选择。

语法格式：

switch (表达式) {
    case 常量值1:
        语句块1;
        break;
    case 常量值2:
        语句块2;
        break;
    // ... 可以有更多的 case
    default: // 可选的
        默认语句块;
        break;
}
  • 表达式：其计算结果的类型必须是 byte, short, char, int。从JDK 1.7开始，也支持String类型。此外，枚举类型也可以用于switch。
  • case：后面必须跟一个与表达式类型兼容的常量值。当表达式的值与某个case的常量值相等时，程序会从该case处开始执行。
  • break：这个关键字的作用是“中断”。当执行完一个case的代码后，break会使程序立即跳出整个switch结构。如果省略break，会导致“Case穿透”现象，即程序会继续执行下一个case的代码，直到遇到break或switch结束。
  • default：当表达式的值与所有case都不匹配时，会执行default中的代码。它类似于if-else if-else结构中最后的else。

示例：使用switch实现一个简单的计算器

char operator = '*';
int num1 = 10;
int num2 = 5;
int result = 0;

switch (operator) {
    case '+':
        result = num1 + num2;
        break;
    case '-':
        result = num1 - num2;
        break;
    case '*':
        result = num1 * num2;
        break;
    case '/':
        result = num1 / num2;
        break;
    default:
        System.out.println("无效的运算符！");
        break;
}
System.out.println(num1 + " " + operator + " " + num2 + " = " + result); // 输出: 10 * 5 = 50

3. 日复一日的工作：循环结构 (Loop Structures)

循环结构使得计算机能够发挥其最强大的优势之一：不厌其烦地执行重复性任务。当我们需要重复执行某段代码直到满足特定条件时，就需要使用循环。

3.1 for 循环：预知次数的循环

如果你明确知道循环需要执行的次数，或者循环变量的初始化、条件和更新非常有规律，那么for循环是你的首选。它的结构紧凑，将循环控制的所有逻辑都集中在了一行。

语法格式：

for (①初始化表达式; ②循环条件; ④更新表达式) {
    // ③循环体
}

执行流程：

  1. ①初始化表达式：仅在循环开始前执行一次。通常用于声明和初始化一个循环控制变量（如int i = 0）。
  2. ②循环条件：在每次进入循环体之前进行判断。若为true，则执行循环体；若为false，则循环结束，程序跳出循环。
  3. ③循环体：循环的核心代码。
  4. ④更新表达式：在每次循环体执行之后执行。通常用于递增或递减循环控制变量（如i++）。
  5. 然后程序流程回到第2步，重复此过程。

示例：打印九九乘法表

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(); // 每行结束后换行
}

3.2 while 循环：条件驱动的未知次数循环

当你不确定循环要执行多少次，只知道循环的继续依赖于某个条件时，while循环是更合适的选择。

语法格式：

初始化语句;
while (循环条件) {
    循环体;
    更新语句;
}

执行流程：while循环是“先判断，后执行”。每次循环开始前，都会先检查循环条件。如果条件为true，就执行循环体；否则，直接跳出循环。

示例：猜数字游戏

int magicNumber = 56;
int guess = -1;
Scanner scanner = new Scanner(System.in);

while (guess != magicNumber) {
    System.out.print("请猜一个数字: ");
    guess = scanner.nextInt();
    if (guess > magicNumber) {
        System.out.println("太大了！");
    } else if (guess < magicNumber) {
        System.out.println("太小了！");
    }
}
System.out.println("恭喜你，猜对了！");

3.3 do-while 循环：确保至少执行一次的循环

do-while循环与while循环非常相似，但有一个根本区别：do-while是“先执行，后判断”。这意味着，不论循环条件是否为true，do-while的循环体至少会被执行一次。

语法格式：

初始化语句;
do {
    循环体;
    更新语句;
} while (循环条件); // 注意，这里必须有一个分号

这种特性使do-while循环非常适合那些需要先执行操作再进行验证的场景，比如菜单驱动的程序。

示例：实现一个简单的用户菜单

Scanner scanner = new Scanner(System.in);
char choice;
do {
    System.out.println("===== 菜单 =====");
    System.out.println("a. 开始游戏");
    System.out.println("b. 加载存档");
    System.out.println("c. 游戏设置");
    System.out.println("q. 退出游戏");
    System.out.print("请输入您的选择: ");
    choice = scanner.next().charAt(0);
    // 这里可以根据choice执行不同操作
} while (choice != 'q');

System.out.println("感谢游玩，再见！");

4. 循环的精细控制：跳转语句

break和continue是两个可以改变循环正常执行流程的关键字。

4.1 break：彻底终结循环

break语句用于立即并完全地终止其所在的最内层的循环结构（for, while, do-while）或switch语句。

示例：在100个产品中寻找残次品```java for (int i = 1; i <= 100; i++) { System.out.println("正在检查第 " + i + " 个产品..."); boolean isDefective = (i == 38); // 假设第38个是残次品 if (isDefective) { System.out.println("发现残次品！停止检查。"); break; // 立即跳出 for 循环 } }


### 4.2 `continue`：跳过本次，继续下一次

`continue`语句用于**结束当前这次循环的执行**，并立即开始下一次循环的迭代。它会跳过`continue`之后的所有语句，直接回到循环的条件判断处（对于`for`循环，会先执行更新表达式）。

**示例：计算1到100所有非7倍数的整数之和**
```java
int total = 0;
for (int i = 1; i <= 100; i++) {
    if (i % 7 == 0) {
        continue; // 如果是7的倍数，跳过本次累加，直接开始下一次循环
    }
    total += i;
}
System.out.println("结果是: " + total);

5. 结语

恭喜您，完成了Java编程中至关重要的一课！在本篇文章中，我们系统地学习了如何使用分支结构（if系列, switch）让程序根据条件执行不同的代码路径，以及如何使用循环结构（for, while, do-while）让程序高效地处理重复性任务。我们还掌握了break和continue这两个强大的工具，它们可以让我们更灵活地控制循环的执行流程。这些流程控制语句是构建任何复杂算法和业务逻辑的基础骨架。

现在，我们已经能够定义数据、操作数据并控制程序的执行流程了。但目前为止，我们操作的还都是单个的变量。如果需要处理大量同类型的数据，比如一个班级所有学生的成绩，我们应该怎么办？这就需要一种能够容纳多个数据的容器。在下一篇文章**【Java之旅：数据的组织者 - 数组的声明、初始化与操作】**中，我们将深入学习Java中最基本的数据结构——数组，它将为您打开批量数据处理的大门。敬请期待！

真诚点赞 诚不我欺