JAVA基础——程序流程控制（循环结构与break、continue）

JAVA基础——程序流程控制（循环结构与break、continue）

一、循环结构概述

循环结构用于重复执行一段代码，直到满足退出条件。Java中有三种循环语句：for、while、do-while，以及break和continue用于控制循环流程。

二、for循环

2.1 格式与执行流程

for (初始化语句; 循环条件; 迭代语句) {
    循环体语句; // 重复执行的代码
}

• 执行流程：

  1. 初始化语句：仅执行一次，用于定义循环变量（如int i = 0）。
  2. 循环条件：每次循环前判断，若为true则执行循环体，否则退出循环。
  3. 循环体语句：重复执行的代码块。
  4. 迭代语句：循环体执行完毕后执行，用于更新循环变量（如i++），然后再次判断循环条件。

• 示例：输出3次"Hello World"

  for (int i = 0; i < 3; i++) {
      System.out.println("Hello World"); // 输出3次
  }
  

2.2 关键点

• 循环变量作用域：初始化语句中定义的变量（如i）仅在循环内可见。
• 省略写法：
  • 初始化语句可省略，但需在循环前定义变量：

    int i = 0;
    for (; i < 3; i++) { ... }
    

  • 循环条件省略：默认为true（死循环，需配合break退出）。
  • 迭代语句可省略，需在循环体内手动更新变量：

    for (int i = 0; i < 3;) {
        System.out.println(i); // 0, 1, 2
        i++; // 手动更新变量
    }
    

三、while循环

3.1 格式与执行流程

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

• 执行流程：

  1. 执行初始化语句（如int i = 0）。
  2. 判断循环条件，若为true执行循环体，否则退出。
  3. 执行迭代语句（如i++），再次判断循环条件。

• 示例：计算1+2+3+4+5

  int sum = 0, i = 1;
  while (i <= 5) {
      sum += i; // sum = 0+1+2+3+4+5=15
      i++;
  }
  

3.2 与for循环的区别

• 功能等价：for和while可以互相转换，但适用场景不同：
  • for：已知循环次数（如“循环5次”）。
  • while：未知循环次数，依赖条件判断（如“直到用户输入正确”）。
• 变量作用域：while的循环变量在循环外可见，for的循环变量仅限循环内。

四、do-while循环

4.1 格式与执行流程

初始化语句;
do {
    循环体语句;
    迭代语句;
} while (循环条件); // 注意分号！

• 执行流程：

  1. 执行初始化语句（如int i = 0）。
  2. 先执行循环体一次，再判断循环条件。
  3. 若条件为true，继续执行循环体；否则退出。

• 示例：至少执行一次的问候

  int i = 10;
  do {
      System.out.println("问候"); // 至少输出一次
      i++;
  } while (i < 5); // 条件为false，仍执行一次
  

4.2 特点

• 先执行后判断：循环体至少执行一次，适用于需要保底执行的场景（如用户登录验证）。

五、死循环

5.1 定义与格式

• 定义：循环条件永远为true，若无干预则无限执行。
• 常见写法：

  // for死循环
  for (; ; ) {
      System.out.println("死循环");
  }
  
  // while死循环
  while (true) {
      System.out.println("死循环");
  }
  
  // do-while死循环
  do {
      System.out.println("死循环");
  } while (true);
  

5.2 应用场景

• 持续监听：如服务器监听端口、游戏主循环。
• 配合break退出：在循环内通过条件判断break退出。

  while (true) {
      int num = new Random().nextInt(10);
      if (num == 5) {
          break; // 随机到5时退出循环
      }
  }
  

六、循环嵌套

6.1 定义

• 概念：循环体内包含另一个循环，外层循环每执行一次，内层循环完整执行一轮。
• 示例：打印3行5列星号

  for (int i = 0; i < 3; i++) { // 外层循环控制行数
      for (int j = 0; j < 5; j++) { // 内层循环控制列数
          System.out.print("*"); // 不换行，横向打印
      }
      System.out.println(); // 换行
  }
  // 输出：
  // *****
  // *****
  // *****
  

6.2 执行流程

• 外层循环变量i从0到2（3次），每次i变化时，内层循环变量j从0到4（5次），内层循环完整执行5次后，外层循环继续。

七、break与continue

7.1 break

• 作用：
  1. 跳出当前循环：结束所在的循环体（for、while、do-while）。
  2. 跳出switch分支：在switch中终止当前case的执行。
• 示例：找到第一个偶数

  for (int i = 1; i <= 10; i++) {
      if (i % 2 == 0) {
          System.out.println("第一个偶数：" + i); // 输出：2
          break; // 跳出循环
      }
  }
  

7.2 continue

• 作用：跳过当前循环的当次执行，直接进入下一次循环。
• 示例：打印1-10中的奇数

  for (int i = 1; i <= 10; i++) {
      if (i % 2 == 0) {
          continue; // 跳过偶数
      }
      System.out.print(i + " "); // 输出：1 3 5 7 9
  }
  

7.3 对比

7.4 注意事项

• 多层嵌套场景：
  • break和continue默认只影响最内层循环。
  • 若需跳出外层循环，可配合标签（Label）：

    outer: for (int i = 0; i < 3; i++) { // 外层循环标签
        for (int j = 0; j < 3; j++) {
            if (i == 1 && j == 1) {
                break outer; // 跳出标签outer对应的外层循环
            }
        }
    }
    

八、循环结构对比表

九、典型案例

9.1 for循环：计算1-100偶数和

int sum = 0;
for (int i = 1; i <= 100; i++) {
    if (i % 2 == 0) {
        sum += i; // 累加偶数
    }
}
System.out.println("1-100偶数和：" + sum); // 输出：2550

9.2 while循环：猜数字游戏

import java.util.Random;
import java.util.Scanner;

public class GuessGame {
    public static void main(String[] args) {
        Random r = new Random();
        int target = r.nextInt(100) + 1; // 1-100随机数
        Scanner sc = new Scanner(System.in);

        while (true) {
            System.out.print("请猜数字（1-100）：");
            int guess = sc.nextInt();
            if (guess > target) {
                System.out.println("猜大了！");
            } else if (guess < target) {
                System.out.println("猜小了！");
            } else {
                System.out.println("猜对了！");
                break; // 猜中后退出循环
            }
        }
    }
}

9.3 do-while循环：用户登录验证

import java.util.Scanner;

public class Login {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String password;
        do {
            System.out.print("请输入密码（6位数字）：");
            password = sc.nextLine();
            if (password.length() != 6) {
                System.out.println("密码必须6位！");
            }
        } while (password.length() != 6); // 至少验证一次
        System.out.println("登录成功！");
    }
}

十、常见错误与注意事项

1. 循环条件错误：
   • 错误：for (int i = 0; i <= 5; i--) （i永远>=0，死循环）。
   • 解决：确保迭代语句正确更新循环变量。
2. 忘记迭代语句：
   • 错误：while (i < 5) { sum += i; }（i未更新，死循环）。
   • 解决：在循环体内添加迭代语句（如i++）。
3. break/continue误用：
   • 错误：在switch外使用break退出循环（需在循环内使用）。
   • 解决：明确break/continue作用范围，必要时使用标签。

十一、总结

• 循环结构是编程中实现重复逻辑的核心，需根据场景选择合适的循环类型。
• break和continue是控制循环流程的关键工具，需熟练掌握其用法与区别。
• 循环嵌套用于处理多层重复逻辑，需注意内外层循环变量的配合。

通过理解循环的执行原理和控制语句的细节，可以高效编写复杂的业务逻辑，避免死循环和逻辑错误。