上一篇我们掌握了Java基础语法的"基石"------变量、数据类型与运算符，能编写简单的计算逻辑，但这些代码都是"顺序执行"的（从第一行执行到最后一行），无法实现复杂的逻辑判断和重复操作。而实际开发中，我们经常需要"根据条件判断执行不同代码"（比如判断成绩是否及格）、"重复执行某段代码"（比如打印10次Hello World），这就需要用到Java的流程控制。
流程控制是Java代码的"骨架"，决定了代码的执行顺序，核心分为两大类：分支结构（if-else、switch）和循环结构（for、while、do-while）。本篇文章将从基础用法入手，结合实战案例，手把手教你掌握每一种流程控制的语法、适用场景，拆解新手高频语法错误和优化技巧，同时对比传统switch与Java 12+增强switch的优势，让你能灵活运用流程控制，编写逻辑清晰、高效的代码。
核心目标：掌握if-else、switch（含增强版）的语法与使用场景，熟练运用for、while、do-while循环实现重复操作，学会循环控制（break/continue/return），能独立完成打印金字塔、九九乘法表等实战案例，规避流程控制中的常见坑。
一、前置认知：什么是流程控制？为什么需要它？
流程控制，简单来说，就是"控制代码的执行顺序"。Java中默认的代码执行顺序是"顺序结构"------从上到下、从左到右依次执行，就像走直线，没有分支、没有回头。但实际开发中，这种"一条路走到黑"的执行方式，无法满足复杂需求。
举两个常见场景：
-
场景1：判断学生成绩，≥60分输出"及格"，＜60分输出"不及格"------需要"根据条件选择执行不同代码"，这就需要分支结构；
-
场景2：打印1到100的所有整数，或者打印5次"Java加油"------需要"重复执行某段代码"，这就需要循环结构。
核心结论：流程控制让代码从"顺序执行"变得"灵活可控"，是实现复杂逻辑的核心，没有流程控制，就无法编写有实际意义的程序（比如学生管理系统、计算器等）。
二、分支结构：根据条件，选择不同的执行路径
分支结构的核心是"判断条件"，根据条件的"成立（true）"或"不成立（false）"，执行不同的代码块。Java中常用的分支结构有两种：if-else（灵活，适合多条件判断）和switch（简洁，适合固定值匹配）。
2.1 if-else分支（最常用，灵活适配多条件）
if-else是最基础、最灵活的分支结构，分为3种用法：单if、if-else、if-else if-else，根据判断条件的复杂程度选择使用。
（1）单if结构：满足条件才执行，不满足则跳过
语法格式（固定写法）：
java
if (判断条件) {
// 条件成立（true）时，执行的代码块
代码语句1;
代码语句2;
}
// 条件不成立（false）时，跳过代码块，执行这里的代码关键说明：
-
判断条件：必须是boolean类型（true/false），可以是单纯的boolean变量，也可以是关系表达式、逻辑表达式（比如age > 18、score ≥ 60 && score ≤ 100）；
-
大括号"{}"：如果代码块中只有一行代码，大括号可以省略（不推荐，容易出错）；如果有多行代码，大括号必须加；
-
执行逻辑：条件成立，执行大括号内的代码；条件不成立，直接跳过代码块，执行后续代码。
实战案例：判断一个数是否是正数
java
public class IfDemo1 {
public static void main(String[] args) {
int num = 10;
// 判断num是否是正数
if (num > 0) {
System.out.println(num + "是正数");
}
System.out.println("程序执行完毕");
}
}运行结果：10是正数 → 程序执行完毕（条件成立，执行代码块；后续代码正常执行）；
若num = -5，运行结果：程序执行完毕（条件不成立，跳过代码块）。
（2）if-else结构：二选一，满足条件执行一个，不满足执行另一个
语法格式：
java
if (判断条件) {
// 条件成立（true）时，执行的代码块
} else {
// 条件不成立（false）时，执行的代码块
}核心特点：if和else是"互斥"的，只能执行其中一个代码块，不会同时执行，也不会都不执行。
实战案例：判断学生成绩是否及格（最经典场景）
java
public class IfDemo2 {
public static void main(String[] args) {
double score = 75.5;
// 判断成绩是否及格（≥60及格）
if (score >= 60) {
System.out.println("成绩及格，继续加油！");
} else {
System.out.println("成绩不及格，需要补考！");
}
}
}运行结果：成绩及格，继续加油！（若score = 59.9，输出"成绩不及格，需要补考！"）
（3）if-else if-else结构：多条件选择，满足哪个执行哪个
语法格式：
java
if (条件1) {
// 条件1成立，执行这里
} else if (条件2) {
// 条件1不成立，条件2成立，执行这里
} else if (条件3) {
// 条件1、2不成立，条件3成立，执行这里
} ... // 可以有多个else if
else {
// 所有条件都不成立，执行这里（可选）
}核心特点：
-
多个条件依次判断，只要有一个条件成立，就执行对应的代码块，后续的条件不再判断（效率高）；
-
else是可选的，如果所有条件都不成立，且没有else，就什么都不执行；
-
条件之间要注意"互斥"或"顺序"，避免逻辑错误（比如先判断score > 90，再判断score > 80，否则score > 90的条件永远不会执行）。
实战案例：根据成绩划分等级（优秀、良好、及格、不及格）
java
public class IfDemo3 {
public static void main(String[] args) {
double score = 88.0;
// 多条件判断成绩等级
if (score >= 90 && score <= 100) {
System.out.println("优秀");
} else if (score >= 80 && score < 90) {
System.out.println("良好");
} else if (score >= 60 && score < 80) {
System.out.println("及格");
} else if (score >= 0 && score < 60) {
System.out.println("不及格");
} else {
System.out.println("成绩输入错误！");
}
}
}运行结果：良好（根据score的不同，输出对应等级；若输入105，输出"成绩输入错误！"）。
if-else常见避坑点（新手必看）
-
忘记加大括号：如果代码块有多行，忘记加大括号，Java会只把第一行代码当作if/else的执行内容，后续代码会不受条件控制，导致逻辑错误；
-
条件判断逻辑错误：比如判断"成绩在60到100之间"，写成"60 ≤ score ≤ 100"（Java不支持这种写法），正确写法是"score ≥ 60 && score ≤ 100"；
-
else if顺序颠倒：比如先判断"score > 60"，再判断"score > 90"，会导致"score > 90"的条件永远无法执行，应按"从大到小"或"从小到大"的顺序排列条件。
2.2 switch分支（适合固定值匹配，简洁高效）
switch分支适合"判断一个变量是否等于某个固定值"的场景（比如根据月份判断季节、根据性别输出问候语），比if-else if-else更简洁、可读性更强。Java 12之后，新增了增强switch，简化了语法，避免了传统switch的"break遗漏"问题。
（1）传统switch语法（Java 12之前）
语法格式：
java
switch (变量) {
case 值1:
// 变量等于值1时，执行的代码
代码语句;
break; // 跳出switch，避免继续执行后续case（重点）
case 值2:
// 变量等于值2时，执行的代码
代码语句;
break;
... // 多个case
default:
// 变量不等于任何case值时，执行的代码（可选）
代码语句;
break; // 可省略，但建议加上
}关键说明：
-
switch后的变量，只能是byte、short、int、char，以及Java 5+的枚举（enum）、Java 7+的String类型，不能是double、float、boolean类型；
-
case后的"值"，必须是和变量类型一致的常量（不能是变量），且不能重复；
-
break关键字：必须加，否则会出现"case穿透"（执行完当前case后，不跳出，继续执行下一个case的代码）；
-
default：可选，位置可以任意（建议放在最后），当所有case都不匹配时执行。
实战案例：根据月份判断季节（传统switch）
java
public class SwitchDemo1 {
public static void main(String[] args) {
int month = 3;
switch (month) {
case 3:
case 4:
case 5: // 多个case可以执行同一套代码（无需重复写代码）
System.out.println("春季");
break;
case 6:
case 7:
case 8:
System.out.println("夏季");
break;
case 9:
case 10:
case 11:
System.out.println("秋季");
break;
case 12:
case 1:
case 2:
System.out.println("冬季");
break;
default:
System.out.println("月份输入错误！");
break;
}
}
}运行结果：春季（month=3，匹配case 3，执行代码后break跳出）；
避坑点8（case穿透）：如果忘记加break，比如case 3后没有break，会继续执行case 4、case 5的代码，最终还是输出"春季"，但逻辑不严谨，容易出错，务必记得加break。
（2）增强switch语法（Java 12+，推荐使用）
Java 12新增的增强switch，解决了传统switch"break遗漏""语法繁琐"的问题，支持"箭头语法"，无需手动加break，且可以直接返回值，语法更简洁、更安全。
语法格式（两种常用写法）：
java
// 写法1：执行代码块（无需break）
switch (变量) {
case 值1 -> { 代码语句; }
case 值2 -> { 代码语句; }
...
default -> { 代码语句; }
}
// 写法2：直接返回值（更简洁，适合单一返回场景）
变量类型 结果 = switch (变量) {
case 值1 -> 值A;
case 值2 -> 值B;
...
default -> 值C;
};增强switch的优势：
-
无需加break，自动跳出switch，避免case穿透；
-
语法更简洁，箭头"->"替代了"case:"和"break"；
-
支持直接返回值，无需额外定义变量存储结果；
-
case可以合并（比如case 3,4,5 -> ...），更简洁。
实战案例：根据月份判断季节（增强switch，推荐）
java
public class SwitchDemo2 {
public static void main(String[] args) {
int month = 7;
// 写法1：执行代码块
switch (month) {
case 3,4,5 -> System.out.println("春季"); // 合并case，简洁
case 6,7,8 -> System.out.println("夏季");
case 9,10,11 -> System.out.println("秋季");
case 12,1,2 -> System.out.println("冬季");
default -> System.out.println("月份输入错误！");
}
// 写法2：直接返回值
String season = switch (month) {
case 3,4,5 -> "春季";
case 6,7,8 -> "夏季";
case 9,10,11 -> "秋季";
case 12,1,2 -> "冬季";
default -> "未知季节";
};
System.out.println("当前季节：" + season);
}
}运行结果：夏季 → 当前季节：夏季（语法简洁，无break，避免穿透，推荐新手使用）。
switch常见避坑点
-
传统switch忘记加break，导致case穿透；
-
switch后的变量类型错误（比如用double、boolean）；
-
case后的"值"是变量（比如case month1，错误），必须是常量；
-
增强switch中，箭头"->"后面如果是代码块，必须加大括号；如果是单一值，无需加括号。
if-else vs switch：如何选择？
很多新手会疑惑，什么时候用if-else，什么时候用switch？记住两个核心原则：
-
如果是"范围判断"（比如score ≥ 60、age > 18），用if-else（灵活，支持任意条件）；
-
如果是"固定值匹配"（比如月份、性别、状态码），用switch（简洁，效率高，尤其是增强switch）。
三、循环结构：重复执行某段代码，提升效率
循环结构的核心是"重复执行"------当满足循环条件时，反复执行某段代码块，直到条件不成立时停止。Java中常用的循环结构有3种：for循环（最常用，适合已知循环次数）、while循环（适合未知循环次数，先判断后执行）、do-while循环（适合未知循环次数，先执行后判断）。
3.1 for循环（最常用，已知循环次数）
for循环是最灵活、最常用的循环，适合"已知循环次数"的场景（比如打印1到100、打印5次Hello World），语法格式固定，可读性强。
（1）for循环语法格式
java
for (初始化语句; 循环条件; 迭代语句) {
// 循环体：条件成立时，重复执行的代码块
}各部分作用（重点理解）：
-
初始化语句：循环开始前执行一次，用于定义循环变量（比如int i = 0），只执行一次；
-
循环条件：每次循环开始前判断，必须是boolean类型（true/false）；条件成立，执行循环体；条件不成立，终止循环；
-
迭代语句：每次循环体执行完毕后执行，用于修改循环变量（比如i++、i--），让循环条件逐渐不成立（避免无限循环）；
-
循环体：需要重复执行的代码，多行代码必须加大括号。
执行流程（必懂）：初始化语句 → 判断循环条件（成立）→ 执行循环体 → 执行迭代语句 → 再次判断循环条件 → ... → 条件不成立，终止循环。
（2）for循环实战案例
案例1：打印1到10的所有整数（已知循环次数：10次）
java
public class ForDemo1 {
public static void main(String[] args) {
// 初始化语句：int i = 1（从1开始）；循环条件：i ≤ 10（到10结束）；迭代语句：i++（每次+1）
for (int i = 1; i <= 10; i++) {
System.out.print(i + " "); // print不换行，println换行
}
}
}运行结果：1 2 3 4 5 6 7 8 9 10（循环10次，每次打印i的值，i从1递增到10）。
案例2：打印1到100的所有偶数（循环次数已知，加条件判断）
java
public class ForDemo2 {
public static void main(String[] args) {
// 循环1到100，判断i是否是偶数（i % 2 == 0）
for (int i = 1; i <= 100; i++) {
if (i % 2 == 0) {
System.out.print(i + " ");
}
}
}
}案例3：打印九九乘法表（经典实战，嵌套for循环）
嵌套for循环：循环体中再包含一个循环，外层循环控制"行数"，内层循环控制"每行的列数"，是for循环的核心用法。
java
public class ForDemo3 {
public static void main(String[] args) {
// 外层循环：控制行数（1到9行）
for (int i = 1; i <= 9; i++) {
// 内层循环：控制每行的列数（1到当前行数i）
for (int j = 1; j <= i; j++) {
// 打印乘法表达式，\t是制表符，让格式对齐
System.out.print(j + "×" + i + "=" + (j*i) + "\t");
}
System.out.println(); // 每行结束后换行
}
}
}运行结果（格式对齐，清晰美观）：
java
1×1=1
1×2=2 ×2=4
1×3=3 2×3=6 3×3=9
1×4=4 ×4=8 ×4=12 ×4=16
1×5=5 5=10 ×5=15 =20 ×5=25 =6 6=12 3×6=18 ×6=24 6=30 ×6=36
1×7=7 ×7=14 3×7=21 4×7=28 5×7=35 6×7=42 7×7=49 ×8=8 2×8=16 3×8=24 ×8=32 ×8=40 ×8=48 7×8=56 8×8=64 1×9=9 2×9=18 ×9=27 ×9=36 5×9=45 9=54 7×9=63 8×9=72 9×9=81 6× 4 3
6 5 4
1 2 6 5× 4 2×
1×6 5 4×5 3 2× 4 3 2 2 3.2 while循环（未知循环次数，先判断后执行）
while循环适合"未知循环次数"的场景（比如让用户输入密码，直到输入正确为止），语法比for循环更简单，核心是"先判断条件，再执行循环体"。
（1）while循环语法格式
java
// 初始化语句（可选，通常写在while外面）
初始化语句;
while (循环条件) {
// 循环体：条件成立时执行的代码
迭代语句; // 必须有，否则会无限循环
}关键说明：
-
初始化语句：通常写在while循环外面，只执行一次；
-
循环条件：和for循环一样，必须是boolean类型，条件成立执行循环体，不成立终止循环；
-
迭代语句：必须写在循环体中，用于修改循环变量，否则循环条件永远成立，导致"无限循环"（程序卡死）；
-
执行流程：初始化语句 → 判断循环条件（成立）→ 执行循环体 → 执行迭代语句 → 再次判断条件 → ... → 条件不成立，终止循环。
（2）while循环实战案例
案例：让用户输入密码，直到输入正确（未知循环次数，直到密码正确为止）
java
import java.util.Scanner;
public class WhileDemo {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String correctPwd = "123456"; // 正确密码
String inputPwd; // 存储用户输入的密码
// 初始化语句：无需额外初始化，直接判断条件
while (true) { // 无限循环，直到输入正确才跳出
System.out.print("请输入密码：");
inputPwd = scanner.next();
// 判断密码是否正确
if (inputPwd.equals(correctPwd)) {
System.out.println("密码正确，登录成功！");
break; // 跳出while循环
} else {
System.out.println("密码错误，请重新输入！");
}
}
scanner.close();
}
}运行效果：
bash
请输入密码：123
密码错误，请重新输入！
请输入密码：456
密码错误，请重新输入！
请输入密码：123456
密码正确，登录成功！说明：这里用了"while (true)"实现无限循环，通过break关键字跳出循环，是while循环的常用场景。
3.3 do-while循环（未知循环次数，先执行后判断）
do-while循环和while循环类似，也是适合未知循环次数的场景，但核心区别是：先执行一次循环体，再判断循环条件------无论条件是否成立，循环体至少执行一次。
（1）do-while循环语法格式
java
// 初始化语句（可选）
初始化语句;
do {
// 循环体：先执行一次
迭代语句;
} while (循环条件); // 注意：这里有分号关键说明：
-
执行流程：初始化语句 → 执行循环体 → 执行迭代语句 → 判断循环条件 → 条件成立，继续执行循环体；条件不成立，终止循环；
-
循环体至少执行一次（即使条件一开始就不成立）；
-
do-while循环的末尾，必须加";"（新手容易遗漏）。
（2）do-while循环实战案例
案例：让用户输入一个正整数，若输入错误（非正整数），重新输入（循环体至少执行一次，确保用户至少输入一次）
java
import java.util.Scanner;
public class DoWhileDemo {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int num;
do {
System.out.print("请输入一个正整数：");
num = scanner.nextInt();
if (num <= 0) {
System.out.println("输入错误！请输入正整数！");
}
} while (num <= 0); // 条件成立（输入错误），继续循环
System.out.println("你输入的正整数是：" + num);
scanner.close();
}
}运行效果：
java
请输入一个正整数：-5
输入错误！请输入正整数！
请输入一个正整数：0
输入错误！请输入正整数！
请输入一个正整数：10
你输入的正整数是：10说明：即使用户第一次输入错误（-5），循环体也执行了一次（输入操作），这是do-while和while的核心区别。
3.4 循环控制：break、continue、return（控制循环执行）
在循环中，我们经常需要"提前跳出循环""跳过当前循环，执行下一次循环"，这就需要用到循环控制关键字：break、continue、return，三者作用不同，务必区分清楚。
四、新手高频易错点总结（必看，避坑指南）
-
if-else忘记加大括号，导致代码不受条件控制；
-
传统switch忘记加break，出现case穿透；
-
switch后的变量类型错误（比如用double、boolean）；
-
循环忘记写迭代语句，导致无限循环；
-
do-while循环末尾忘记加";"，导致语法错误；
-
混淆break、continue、return的作用，比如用continue跳出循环；
-
嵌套循环中，循环变量命名重复（比如外层和内层都用int i），导致逻辑错误；
-
循环条件设置错误，导致循环体一次都不执行，或无法终止循环。
五、总结与下期预告
本篇文章重点讲解了Java流程控制的核心------分支结构（if-else、switch）和循环结构（for、while、do-while），以及循环控制关键字（break、continue、return）。流程控制是编写复杂Java程序的基础，核心是"根据条件选择执行路径"和"重复执行代码"，通过实战案例（九九乘法表、金字塔、密码验证），相信你已经掌握了基本用法。
动手练习建议：1. 打印1到100的所有奇数；2. 打印倒金字塔；3. 用while循环实现"猜数字游戏"（随机生成一个1-100的数字，让用户猜，直到猜对为止），巩固流程控制的用法。
下期预告：下一篇我们将学习Java数组与字符串，重点讲解数组的定义、初始化、遍历方式，以及String类的核心方法，学会用数组存储多个数据，用字符串处理文本信息，同时拆解常见面试题（比如"String s=new String("abc")创建了几个对象"），为后续学习集合、面向对象进阶铺垫基础。