【Java SE 基础学习打卡】26 跳转语句

目录

• 前言
• 一、先搞懂：跳转语句的核心逻辑（为什么需要它们？）
• [二、逐个攻破：两个跳转语句的用法（语法 + 例子 + 执行顺序）](#二、逐个攻破：两个跳转语句的用法（语法 + 例子 + 执行顺序）)
• • [2.1 break：跳出当前循环 /switch（"提前下班"）](#2.1 break：跳出当前循环 /switch（“提前下班”）)
  • • 1.核心逻辑
    • 2.语法格式
    • [3.生活场景 1：找 100 以内第一个能被 13 整除的数（找到就停）](#3.生活场景 1：找 100 以内第一个能被 13 整除的数（找到就停）)
    • [4.生活场景 2：while 循环中使用 break（密码验证模拟）](#4.生活场景 2：while 循环中使用 break（密码验证模拟）)
  • [2.2 continue：跳过本次循环，进入下一次（"跳过下午茶"）](#2.2 continue：跳过本次循环，进入下一次（“跳过下午茶”）)
  • • 1.核心逻辑
    • 2.语法格式
    • [3.生活场景 1：计算 1-100 的奇数和（跳过偶数）](#3.生活场景 1：计算 1-100 的奇数和（跳过偶数）)
    • [4.生活场景 2：while 循环中使用 continue（跳过负数）](#4.生活场景 2：while 循环中使用 continue（跳过负数）)
    • [5.关键提醒：for 循环和 while 循环中 continue 的区别](#5.关键提醒：for 循环和 while 循环中 continue 的区别)
• [三、break 和 continue 的详细对比（用同一例子验证）](#三、break 和 continue 的详细对比（用同一例子验证）)
• • [3.1 场景：循环打印 1-5，遇到 3 时触发跳转](#3.1 场景：循环打印 1-5，遇到 3 时触发跳转)
  • • [1. 用 break（遇到 3 跳出循环）](#1. 用 break（遇到 3 跳出循环）)
    • [2. 用 continue（遇到 3 跳过，继续下一次）](#2. 用 continue（遇到 3 跳过，继续下一次）)
  • [3.2 对比总结（新手必记）](#3.2 对比总结（新手必记）)
• [四、新手必避的 5 个 "致命坑"](#四、新手必避的 5 个 “致命坑”)
• • [4.1 坑 1：break 在循环 /switch 外使用](#4.1 坑 1：break 在循环 /switch 外使用)
  • [4.2 坑 2：continue 在循环外使用](#4.2 坑 2：continue 在循环外使用)
  • [4.3 坑 3：while 循环中 continue 跳过更新值，导致死循环](#4.3 坑 3：while 循环中 continue 跳过更新值，导致死循环)
  • [4.4 坑 5：循环体漏加大括号，导致跳转语句失效](#4.4 坑 5：循环体漏加大括号，导致跳转语句失效)
• 总结

前言

上一节咱们学了 for 循环，搞定了固定次数的重复操作；之前还学了 while 和 do-while，能处理各种循环场景。但实际编程中，循环往往不是 "一条路走到黑"------ 比如 "找 100 以内第一个能被 7 整除的数，找到就停""打印 1-10，跳过偶数"，这时候就需要 "跳转语句" 来给循环 "装开关"，灵活控制执行流程。

Java 里有两个核心循环跳转语句：break（中断）和 continue（跳过）。它们的作用完全不同：break 是 "直接下班"，遇到条件就终止当前循环；continue 是 "跳过下午茶继续干活"，遇到条件就跳过本次循环剩余内容，直接进入下一次。这一节咱们逐个讲透，用生活化场景 + 超详细代码 + 避坑指南，保证刚学完循环的你能轻松区分和使用！

一、先搞懂：跳转语句的核心逻辑（为什么需要它们？）

跳转语句的本质是：改变循环的默认执行顺序（默认是 "判断→执行→更新" 循环往复），让程序能 "按需中断" 或 "按需跳过"，避免无效执行。比如找目标数时，找到就不用再遍历剩下的；统计奇数和时，不用处理偶数 ------ 这样代码更高效，逻辑也更清晰。

两个跳转语句的核心区别（先有印象）

语句	核心作用	适用场景	是否终止循环	影响范围
break	立即跳出当前所在的循环 /switch 语句	找到目标值、满足条件时提前退出	是（当前循环）	只影响所在的循环 /switch
continue	跳过本次循环剩余代码，直接进入下一次循环	过滤不需要的情况（比如跳过偶数）	否（仅跳过本次）	只影响当前循环的一次执行

**一句话类比：**循环是 "每天上班"，break 是 "今天提前下班（当天工作结束）"，continue 是 "今天跳过下午茶（继续完成当天剩余工作）"。

二、逐个攻破：两个跳转语句的用法（语法 + 例子 + 执行顺序）

2.1 break：跳出当前循环 /switch（"提前下班"）

1.核心逻辑

break 的作用是 "立即跳出当前所在的循环或 switch 语句"，跳出后直接执行循环 /switch 后面的代码。就像上班时突然有事，提前下班，当天的工作（循环）直接结束，但不影响第二天（其他代码）。

2.语法格式

// 循环中使用（while/do-while/for都适用）
循环结构 (循环条件) {
    if (中断条件) {
        break; // 满足条件，跳出当前循环
    }
    循环体代码; // 中断条件成立时，这部分不执行
}

// switch中使用（之前学过，这里回顾，避免穿透）
switch (表达式) {
    case 常量1:
        执行语句1;
        break; // 跳出switch，不执行后续case
    case 常量2:
        执行语句2;
        break;
    default:
        执行语句3;
}

3.生活场景 1：找 100 以内第一个能被 13 整除的数（找到就停）

代码示例

public static void main(String[] args) {
    // 目标：找1-100中第一个能被13整除的数，找到就停止循环（不用找下一个）
    for (int i = 1; i <= 100; i++) {
        // 判断当前i是否能被13整除（余数为0）
        if (i % 13 == 0) {
            System.out.println("找到啦！100以内第一个能被13整除的数是：" + i);
            break; // 跳出for循环，后面的i不再判断
        }
        System.out.println("正在检查：" + i); // 没找到就打印检查信息
    }
    // 循环结束后执行的代码
    System.out.println("循环结束，任务完成～");
}

执行结果（关键部分）：

正在检查：1
正在检查：2
...
正在检查：12
找到啦！100以内第一个能被13整除的数是：13
循环结束，任务完成～

执行顺序拆解

1. 循环初始化：i=1，判断1<=100→true，进入循环体；

2. i=1到i=12：都不满足i%13==0，打印检查信息，i依次递增；

3. i=13：满足i%13==0，打印找到的信息，执行break；

4. 直接跳出 for 循环，执行循环后面的 "循环结束" 语句。

4.生活场景 2：while 循环中使用 break（密码验证模拟）

public static void main(String[] args) {
    int correctPwd = 666666; // 正确密码（用数字模拟）
    int inputPwd = 0; // 模拟输入的密码（从0开始尝试）
    
    while (inputPwd < 999999) { // 密码范围0-999999
        inputPwd += 111111; // 模拟每次输入不同密码（步长111111）
        System.out.println("尝试密码：" + inputPwd);
        
        if (inputPwd == correctPwd) {
            System.out.println("密码正确！登录成功～");
            break; // 找到正确密码，跳出while循环
        }
    }
}

执行结果：

尝试密码：111111
尝试密码：222222
尝试密码：333333
...（中间省略）
尝试密码：666666
密码正确！登录成功～

2.2 continue：跳过本次循环，进入下一次（"跳过下午茶"）

1.核心逻辑

continue 的作用是 "立即跳过当前循环的剩余代码，直接进入下一次循环的条件判断"。就像上班时跳过下午茶，不影响后续工作，当天的班还会继续上，只是跳过这一个环节。

2.语法格式

循环结构 (循环条件) {
    循环体前半部分代码;
    if (跳过条件) {
        continue; // 满足条件，跳过本次循环剩余代码
    }
    循环体后半部分代码; // 跳过条件成立时，这部分不执行
    更新表达式; // for循环中更新表达式在continue后仍会执行
}

3.生活场景 1：计算 1-100 的奇数和（跳过偶数）

代码示例

public static void main(String[] args) {
    int sum = 0; // 存储奇数和
    for (int i = 1; i <= 100; i++) {
        // 判断当前i是否是偶数（能被2整除）
        if (i % 2 == 0) {
            continue; // 跳过偶数，不执行后面的sum累加和打印
        }
        // 只有奇数才会执行这两行代码
        sum += i; // 等价于sum = sum + i
        System.out.println("当前奇数：" + i + "，累计和：" + sum);
    }
    System.out.println("1-100的奇数和：" + sum); // 输出2500
}

执行结果（关键部分）：

当前奇数：1，累计和：1
当前奇数：3，累计和：4
当前奇数：5，累计和：9
...
当前奇数：99，累计和：2500
1-100的奇数和：2500

执行顺序拆解（以 i=2 为例）

1. i=2，判断2<=100→true，进入循环体；

2. 判断2%2==0→true，执行continue；

3. 跳过sum += i和打印语句，直接执行更新表达式i++→3；

4. 进入下一次循环，判断3<=100→true，继续执行。

4.生活场景 2：while 循环中使用 continue（跳过负数）

public static void main(String[] args) {
    int num = -3; // 初始值
    while (num <= 3) {
        num++; // 先更新值（避免死循环）
        
        if (num < 0) {
            System.out.println("跳过负数：" + num);
            continue; // 跳过负数，不执行后面的打印
        }
        
        System.out.println("当前非负数：" + num);
    }
}

执行结果：

跳过负数：-2
跳过负数：-1
当前非负数：0
当前非负数：1
当前非负数：2
当前非负数：3
当前非负数：4

5.关键提醒：for 循环和 while 循环中 continue 的区别

• for 循环中，continue 后会自动执行更新表达式 （比如i++），不用担心死循环；

• while 循环中，continue 后会直接回到 "条件判断"，如果更新表达式在 continue 后面，会被跳过，容易导致死循环：

  // while循环的坑（更新表达式在continue后面）
  int i = 1;
  while (i <= 5) {
      if (i == 3) {
          continue; // 跳过下面的i++，i一直是3，死循环
      }
      System.out.println(i);
      i++; // 更新表达式在continue后面，被跳过
  }

• 正确写法（while 循环中更新表达式放前面）：

  int i = 1;
  while (i <= 5) {
      if (i == 3) {
          i++; // 先更新，再continue
          continue;
      }
      System.out.println(i);
      i++;
  }

三、break 和 continue 的详细对比（用同一例子验证）

为了让你更直观区分，我们用 "循环打印 1-5，遇到 3 时执行不同跳转语句" 做对比：

3.1 场景：循环打印 1-5，遇到 3 时触发跳转

1. 用 break（遇到 3 跳出循环）

public static void main(String[] args) {
    System.out.print("break效果：");
    for (int i = 1; i <= 5; i++) {
        if (i == 3) {
            break; // 跳出循环，后面的i不再执行
        }
        System.out.print(i + " ");
    }
    System.out.println();
}

执行结果：

break效果：1 2 

2. 用 continue（遇到 3 跳过，继续下一次）

public static void main(String[] args) {
    System.out.print("continue效果：");
    for (int i = 1; i <= 5; i++) {
        if (i == 3) {
            continue; // 跳过i=3的打印，进入下一次循环
        }
        System.out.print(i + " ");
    }
    System.out.println();
}

执行结果：

continue效果：1 2 4 5 

3.2 对比总结（新手必记）

• break：遇到条件→循环直接结束；

• continue：遇到条件→本次循环跳过→下一次循环继续；

• 核心区别：是否终止整个循环（break 是，continue 否）。

四、新手必避的 5 个 "致命坑"

4.1 坑 1：break 在循环 /switch 外使用

• 错误示例：

  int i = 1;
  if (i == 1) {
      break; // break只能在循环或switch内使用
  }

• 后果：编译报错！提示 "break 语句不在循环或 switch 语句中"；

• 正确示例：

  for (int i = 1; i <= 5; i++) {
      if (i == 3) {
          break; // 在循环内使用
      }
  }

4.2 坑 2：continue 在循环外使用

• 错误示例：

  int i = 1;
  if (i == 1) {
      continue; // continue只能在循环内使用
  }

• 后果：编译报错！提示 "continue 语句不在循环语句中"；

• 正确示例：

  for (int i = 1; i <= 5; i++) {
      if (i == 3) {
          continue; // 在循环内使用
      }
  }

4.3 坑 3：while 循环中 continue 跳过更新值，导致死循环

• 错误示例：

  int i = 1;
  while (i <= 5) {
      if (i == 3) {
          continue; // 跳过下面的i++，i一直是3
      }
      System.out.println(i);
      i++; // 更新值在continue后面，被跳过
  }

• 后果 ：死循环！i 永远是 3，循环条件一直为true，程序停不下来；

• 正确示例：

  int i = 1;
  while (i <= 5) {
      if (i == 3) {
          i++; // 先更新，再continue
          continue;
      }
      System.out.println(i);
      i++;
  }

4.4 坑 5：循环体漏加大括号，导致跳转语句失效

• 错误示例：

  for (int i = 1; i <= 5; i++)
      if (i == 3)
          break;
      System.out.print(i + " "); // 不受循环控制，还报错（i未定义）

• 后果 ：System.out.print(i + " ")不受循环控制，且 i 是循环内变量，外部无法访问，编译报错；

• 正确示例：

  for (int i = 1; i <= 5; i++) {
      if (i == 3) {
          break;
      }
      System.out.print(i + " ");
  }

总结

这一节咱们学了 break 和 continue 两个循环跳转语句，记住 2 个核心点：

1. break：跳出当前循环 /switch，循环直接结束（"提前下班"）；

2. continue：跳过本次循环剩余代码，进入下一次循环（"跳过下午茶"）。

跳转语句让循环的控制更灵活，能处理 "提前退出""过滤无效数据" 等场景。掌握它们后，你编写的循环代码会更高效、逻辑更清晰。