Java程序控制流基础

在Java编程中，控制流语句用于决定程序执行的顺序。它们允许我们根据特定条件执行不同的代码块，或者重复执行某段代码直到满足特定条件。本节将深入探讨Java中的分支结构、循环结构以及方法的定义与使用。

分支结构：条件执行代码

分支结构允许程序根据表达式的真假来选择性地执行代码。Java主要提供了if语句和switch语句来实现这一功能。

if 语句

if语句用于判断一个条件。如果条件为真，则执行相应的代码块；否则，跳过该代码块。它有多种形式：

• 基本if语句： 当条件为真时执行。

int score = 85;
if (score > 60) {
    System.out.println("考试及格！");
}

• if-else语句： 当条件为真时执行一个代码块，否则执行另一个代码块。

int temperature = 25;
if (temperature > 30) {
    System.out.println("天气炎热，注意防暑！");
} else {
    System.out.println("气温适中。");
}

• if-else if-else语句： 用于处理多个互斥条件，程序将依次检查条件，执行第一个为真的条件对应的代码块。

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

switch 语句

switch语句提供了一种更简洁的方式来处理基于一个变量或表达式值的多分支选择。它会根据表达式的值跳转到匹配的case标签处执行代码。如果没有任何case匹配，则执行default标签后的代码（如果存在）。

char inputChar = 'B';
switch (inputChar) {
    case 'A':
        System.out.println("您输入了字母 A");
        break; // 阻止"穿透"
    case 'B':
        System.out.println("您输入了字母 B");
        // 如果没有 break，会继续执行 case 'C' 的代码
    case 'C':
        System.out.println("您输入了字母 C 或前一个 case 穿透");
        break;
    default:
        System.out.println("输入了其他字符");
        break;
}

注意：在switch的每个case块末尾使用break语句非常重要，否则程序会"穿透"到下一个case中执行，直到遇到break或switch语句结束。这是switch语句的一个重要特性，有时可以用于实现特定逻辑，但在大多数情况下都需要避免意外的穿透。

循环结构：重复执行代码

循环结构用于重复执行一段代码，直到指定的条件不再满足。Java提供了for、while和do-while三种循环语句。

for 循环

for循环是Java中最常用的循环结构之一，适用于已知循环次数的情况。它的结构清晰，在一个语句中包含了初始化、循环条件和迭代更新。

for (int counter = 0; counter < 5; counter++) {
    System.out.println("当前计数：" + counter);
}
// 输出:
// 当前计数：0
// 当前计数：1
// 当前计数：2
// 当前计数：3
// 当前计数：4

执行流程：

1. 初始化表达式：在循环开始前执行一次，通常用于声明和初始化循环变量。
2. 条件表达式：在每次循环迭代前进行判断。如果为真，则执行循环体；如果为假，则终止循环。
3. 循环体：当条件为真时执行的代码块。
4. 迭代更新表达式：在每次循环体执行完毕后执行，通常用于更新循环变量的值。

while 循环

while循环适用于循环次数不确定，只知道循环结束条件的情况。只要条件为真，循环就会持续执行。

int repeatCount = 0;
while (repeatCount < 3) {
    System.out.println("执行第 " + (repeatCount + 1) + " 次循环。");
    repeatCount++; // 迭代语句，防止死循环
}
// 输出:
// 执行第 1 次循环。
// 执行第 2 次循环。
// 执行第 3 次循环。

for与while的选择：当你明确知道循环的迭代次数时，通常推荐使用for循环，因为它将所有循环控制信息集中在一行。而当循环次数不确定，仅依赖于某个条件是否满足时，while循环更为合适。

do-while 循环

do-while循环与while循环类似，但它保证循环体至少执行一次，因为条件判断发生在循环体执行之后。

import java.util.Scanner;

// 假设我们希望至少提示用户输入一次，然后根据输入决定是否继续
public class InputExample {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String userChoice;
        do {
            System.out.println("请选择一个操作 (输入 'exit' 退出):");
            userChoice = scanner.nextLine();
            System.out.println("您选择了: " + userChoice);
        } while (!userChoice.equalsIgnoreCase("exit"));
        scanner.close();
        System.out.println("程序退出。");
    }
}

无限循环

在某些特定场景下，我们可能需要一个无限循环（也称死循环）。以下是实现无限循环的常见方式：

• for循环： for ( ; ; ) { /* 代码 */ }
• while循环：： while (true) { /* 代码 */ }
• do-while循环：： do { /* 代码 */ } while (true);

无限循环通常需要配合break语句或其他控制机制来终止。

循环嵌套

循环可以嵌套使用，即在一个循环体内包含另一个循环。这在处理二维数据结构或需要多层迭代的场景中非常常见，例如打印矩阵或生成九九乘法表。

System.out.println("打印简单的矩形模式:");
for (int row = 0; row < 4; row++) { // 外层循环控制行数
    for (int col = 0; col < 6; col++) { // 内层循环控制列数
        System.out.print("* "); // 打印星号和空格
    }
    System.out.println(); // 每打印完一行后换行
}
// 输出:
// 打印简单的矩形模式:
// * * * * * * 
// * * * * * * 
// * * * * * * 
// * * * * * * 

循环控制关键字：break 与 continue

Java提供了两个特殊的关键字来更精细地控制循环的执行流程：

• break： 用于立即终止当前所在的循环（for, while, do-while）的执行，并跳到循环语句的下一条语句。
• continue： 用于跳过当前循环的剩余语句，直接进入下一次迭代的条件判断。

for (int k = 1; k <= 10; k++) {
    if (k == 5) {
        System.out.println("遇到5，跳出循环。");
        break; // 当 k 为 5 时，循环将终止
    }
    if (k % 2 == 0) {
        System.out.println("跳过偶数 " + k);
        continue; // 当 k 为偶数时，跳过当前迭代的剩余部分，直接进入下一次循环
    }
    System.out.println("处理数字: " + k);
}
// 输出:
// 处理数字: 1
// 跳过偶数 2
// 处理数字: 3
// 跳过偶数 4
// 遇到5，跳出循环。

生成随机数：java.util.Random 类

在Java中，java.util.Random类用于生成伪随机数。这在模拟、游戏或需要随机选择的场景中非常有用。

1. 导入包： import java.util.Random;
2. 创建Random对象：： Random randomNumberGenerator = new Random();
3. 生成随机数：
   • nextInt(bound)： 生成一个介于 0（包含）和 bound（不包含）之间的随机整数。例如，randomNumberGenerator.nextInt(10) 会生成 0 到 9 之间的整数。
   • 生成指定范围的随机数：

     要生成一个介于 min（包含）和 max（包含）之间的随机整数，可以使用公式：
     randomNumberGenerator.nextInt(max - min + 1) + min;

     示例： 生成 1 到 10（含）之间的随机整数：

     int randomNum1to10 = randomNumberGenerator.nextInt(10 - 1 + 1) + 1; // 等同于 nextInt(10) + 1

     示例： 生成 5 到 15（含）之间的随机整数：

     int randomNum5to15 = randomNumberGenerator.nextInt(15 - 5 + 1) + 5; // 等同于 nextInt(11) + 5

方法：代码的模块化与复用

方法（或称函数）是一段执行特定任务或操作的代码块。它是Java程序的基本组织单元，将复杂的逻辑分解为可管理、可重用的部分。

方法的使用与优势：

• 封装功能： 将一组相关的操作封装在一个方法中，使其具有清晰的职责。
• 提高复用性： 一旦定义，方法可以在程序的任何地方被多次调用，避免代码重复。
• 提高开发效率： 通过复用现有方法，可以加快开发速度。
• 增强可读性与维护性： 将大程序分解为小方法，使代码结构更清晰，易于理解和维护。

简单方法示例：

public class Calculator {

    /**
     * 计算两个整数的和并返回结果。
     * @param num1 第一个操作数
     * @param num2 第二个操作数
     * @return 两个数的和
     */
    public int add(int num1, int num2) {
        return num1 + num2;
    }

    /**
     * 打印一条欢迎消息。
     * @param name 要欢迎的人的名字
     */
    public void greetUser(String name) {
        System.out.println("欢迎您，" + name + "!");
    }

    public static void main(String[] args) {
        Calculator myCalc = new Calculator();
        int sumResult = myCalc.add(10, 20);
        System.out.println("10 + 20 = " + sumResult); // 输出: 10 + 20 = 30

        myCalc.greetUser("Java开发者"); // 输出: 欢迎您，Java开发者!
    }
}