在 Java 中，分支逻辑用于让代码根据条件判断执行不同分支，循环逻辑用于让代码满足条件时重复执行，二者是 Java 编程的基础核心，且常组合使用解决实际问题。下面从核心语法、实操案例、使用场景、核心注意事项四个维度，讲清分支和循环的具体使用方法，代码可直接复制运行，新手也能快速上手。

一、分支逻辑的使用：让代码 “做选择”

Java 中分支逻辑主要有 **if-else（含if-else if-else）和switch-case两种，前者适配范围条件判断 **，后者适配固定值精准匹配，是分支的唯二核心写法。

1. if-else：范围条件判断（最常用）

核心语法

java

运行

// 单分支：仅满足条件时执行
if (布尔条件) {
    满足条件执行的代码;
}

// 双分支：二选一执行
if (布尔条件) {
    满足条件执行的代码;
} else {
    不满足条件执行的代码;
}

// 多分支：多条件二选一，从上到下匹配，满足即执行并跳出
if (布尔条件1) {
    满足条件1执行的代码;
} else if (布尔条件2) {
    满足条件2执行的代码;
} 
// 可加多个else if
else {
    所有条件都不满足时执行的代码;
}

实操案例：判断学生成绩等级

java

运行

public class IfElseDemo {
    public static void main(String[] args) {
        int score = 78;
        // 多分支判断分数范围
        if (score >= 90) {
            System.out.println("优秀");
        } else if (score >= 80) {
            System.out.println("良好");
        } else if (score >= 60) {
            System.out.println("及格");
        } else {
            System.out.println("不及格");
        }
    }
}

运行结果：及格

2. switch-case：固定值精准匹配

适配枚举、整数、字符串（Java 7 + 支持）等固定值的匹配场景，替代多层if-else让代码更简洁。

核心语法

java

运行

switch (匹配值) { // 匹配值类型：byte/short/int/char/枚举/String
    case 固定值1:
        匹配成功执行的代码;
        break; // 跳出switch，必须写，否则会“穿透”到下一个case
    case 固定值2:
        匹配成功执行的代码;
        break;
    // 可加多个case
    default: // 所有case都不匹配时执行，可选写，位置可随意（建议放最后）
        默认执行的代码;
        break;
}

实操案例：根据数字匹配星期

java

运行

public class SwitchDemo {
    public static void main(String[] args) {
        int week = 3;
        switch (week) {
            case 1:
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
                break;
            case 4:
                System.out.println("星期四");
                break;
            case 5:
                System.out.println("星期五");
                break;
            case 6:
                System.out.println("星期六");
                break;
            case 7:
                System.out.println("星期日");
                break;
            default:
                System.out.println("输入的星期数无效");
                break;
        }
    }
}

运行结果：星期三

关键注意点：case 穿透

如果省略break，代码会从匹配的 case 开始，依次执行后续所有 case 的代码（无论是否匹配），这是新手最易踩的坑，除非业务需要（如多个值执行同一逻辑），否则必须加break。

分支逻辑使用场景总结

表格

分支类型	适用场景	优点
if-else	范围判断（如分数、年龄）	灵活，适配所有条件
switch-case	固定值匹配（如菜单、星期）	代码简洁，可读性高

二、循环逻辑的使用：让代码 “重复做”

Java 中循环逻辑核心有三种：for循环、while循环、do-while循环，三者均可实现循环，区别仅在语法结构和执行时机，核心都是「条件满足则循环，不满足则退出」。

1. for循环：明确循环次数时使用（最常用）

适配已知循环次数的场景（如遍历 1~100、遍历数组 / 集合），语法将「初始化变量、循环条件、更新变量」集中在一处，代码简洁易维护。

核心语法

java

运行

for (初始化循环变量; 布尔循环条件; 更新循环变量) {
    循环体：满足条件时重复执行的代码;
}
// 执行流程：初始化 → 判断条件 → 执行循环体 → 更新变量 → 再次判断条件（循环）

实操案例 1：打印 1~10 的数字

java

运行

public class ForDemo1 {
    public static void main(String[] args) {
        // i从1开始，<=10时循环，每次循环后i+1
        for (int i = 1; i <= 10; i++) {
            System.out.print(i + " ");
        }
    }
}

运行结果：1 2 3 4 5 6 7 8 9 10

实操案例 2：计算 1~100 的累加和

java

运行

public class ForDemo2 {
    public static void main(String[] args) {
        int sum = 0; // 保存累加和
        for (int i = 1; i <= 100; i++) {
            sum += i; // 等价于sum = sum + i
        }
        System.out.println("1~100累加和：" + sum);
    }
}

运行结果：1~100 累加和：5050

2. while循环：未知循环次数，仅知结束条件时使用

适配不知道循环多少次，只知道循环结束的条件的场景（如用户输入正确值才退出），语法仅需循环条件，初始化和更新变量需写在外部。

核心语法

java

运行

// 1. 初始化循环变量（必须写在外部）
循环变量类型 变量名 = 初始值;
// 2. 判断循环条件，满足则执行循环体
while (布尔循环条件) {
    循环体：满足条件时重复执行的代码;
    // 3. 更新循环变量（必须写，否则死循环）
    变量更新语句;
}

实操案例：让用户输入数字，直到输入 0 退出

java

运行

import java.util.Scanner; // 导入扫描器，用于接收用户输入

public class WhileDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int num = 1; // 初始化变量，避免第一次判断条件时报错
        // 条件：num不等于0时一直循环
        while (num != 0) {
            System.out.print("请输入一个数字（输入0退出）：");
            num = sc.nextInt(); // 接收用户输入，更新变量
            System.out.println("你输入的数字是：" + num);
        }
        sc.close(); // 关闭扫描器，释放资源
    }
}

运行效果：

plaintext

请输入一个数字（输入0退出）：5
你输入的数字是：5
请输入一个数字（输入0退出）：8
你输入的数字是：8
请输入一个数字（输入0退出）：0
你输入的数字是：0

3. do-while循环：至少执行一次循环体时使用

是while循环的变体，区别在于：先执行一次循环体，再判断循环条件，适配「无论条件是否满足，都必须先执行一次」的场景（如密码验证、菜单选择）。

核心语法

java

运行

// 1. 初始化循环变量（可选，根据业务需求）
循环变量类型 变量名 = 初始值;
do {
    // 2. 循环体：先执行一次，再判断条件
    重复执行的代码;
    // 3. 更新循环变量（必须写，否则死循环）
    变量更新语句;
} while (布尔循环条件); // 注意：末尾有分号

实操案例：密码验证，至少输入一次密码

java

运行

import java.util.Scanner;

public class DoWhileDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String password = ""; // 初始化密码变量
        // 先执行一次输入，再判断是否正确
        do {
            System.out.print("请输入密码（正确密码：123456）：");
            password = sc.next();
        } while (!"123456".equals(password)); // 密码不等于123456时继续循环
        
        System.out.println("密码正确，登录成功！");
        sc.close();
    }
}

运行效果：

plaintext

请输入密码（正确密码：123456）：123
请输入密码（正确密码：123456）：654321
请输入密码（正确密码：123456）：123456
密码正确，登录成功！

循环逻辑核心注意事项

1. 避免死循环：循环内必须更新循环变量（如i++、num = sc.nextInt()），否则循环条件永远满足，代码会无限执行；
2. 循环条件是布尔值：只能写true/false或返回布尔值的表达式（如i<=10、num!=0）；
3. 循环体单行可省略大括号：但建议始终加，避免代码可读性差和逻辑错误。

循环逻辑使用场景总结

表格

循环类型	适用场景	核心特点
for	已知循环次数（如遍历数字）	初始化 / 条件 / 更新集中管理
while	未知循环次数，知结束条件	先判断条件，再执行循环体
do-while	至少执行一次循环体	先执行循环体，再判断条件

三、分支 + 循环的组合使用（实战核心）

实际开发中，分支和循环几乎不会单独使用，而是组合实现复杂业务逻辑（如猜数字、遍历筛选数据、菜单系统），下面通过 2 个经典实战案例，讲清组合使用的思路。

案例 1：遍历 1~20，打印其中的偶数（循环遍历 + 分支判断）

java

运行

public class LoopWithIf {
    public static void main(String[] args) {
        // for循环遍历1~20（已知次数）
        for (int i = 1; i <= 20; i++) {
            // if分支判断是否为偶数（i%2==0 表示能被2整除）
            if (i % 2 == 0) {
                System.out.print(i + " ");
            }
        }
    }
}

运行结果：2 4 6 8 10 12 14 16 18 20

案例 2：简易菜单系统（循环保持菜单 + 分支执行功能）

实现「菜单一直显示，用户选择对应功能，选择 0 退出」的效果，组合do-while（至少显示一次菜单）+switch（匹配菜单选项）。

java

运行

import java.util.Scanner;

public class MenuSystem {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int choice = 0;
        // do-while：至少显示一次菜单
        do {
            // 打印菜单（顺序逻辑）
            System.out.println("===== 简易菜单 =====");
            System.out.println("1. 查看个人信息");
            System.out.println("2. 修改密码");
            System.out.println("3. 查看消息");
            System.out.println("0. 退出系统");
            System.out.print("请选择功能编号：");
            choice = sc.nextInt();
            
            // switch：分支匹配用户选择
            switch (choice) {
                case 1:
                    System.out.println("你的姓名：张三，年龄：20");
                    break;
                case 2:
                    System.out.println("密码修改成功！");
                    break;
                case 3:
                    System.out.println("你有1条未读消息");
                    break;
                case 0:
                    System.out.println("退出系统，再见！");
                    break;
                default:
                    System.out.println("输入错误，请选择0~3的编号！");
                    break;
            }
            System.out.println("-------------------\n");
        } while (choice != 0); // 选择0时退出循环
        
        sc.close();
    }
}

运行效果：

plaintext

===== 简易菜单 =====
1. 查看个人信息
2. 修改密码
3. 查看消息
0. 退出系统
请选择功能编号：1
你的姓名：张三，年龄：20
-------------------

===== 简易菜单 =====
1. 查看个人信息
2. 修改密码
3. 查看消息
0. 退出系统
请选择功能编号：0
退出系统，再见！
-------------------

四、循环的辅助关键字：break 和 continue

在循环中可通过break和continue灵活控制循环流程，是循环使用的进阶技巧，新手需区分二者的核心差异。

1. break：直接跳出当前循环 /switch

作用：终止所在的循环（for/while/do-while）或 switch，执行循环 /switch 之后的代码。

案例：遍历 1~10，遇到 5 则跳出循环

java

运行

public class BreakDemo {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            if (i == 5) {
                break; // 遇到5，跳出整个for循环
            }
            System.out.print(i + " ");
        }
    }
}

运行结果：1 2 3 4

2. continue：跳过本次循环，继续下一次循环

作用：终止当前次的循环体执行，直接跳转到「更新变量」（for）或「条件判断」（while/do-while），继续下一次循环。

案例：遍历 1~10，跳过 5，打印其他数字

java

运行

public class ContinueDemo {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            if (i == 5) {
                continue; // 跳过本次循环，不打印5，继续下一次
            }
            System.out.print(i + " ");
        }
    }
}

运行结果：1 2 3 4 6 7 8 9 10

五、核心知识点总结

1. 分支逻辑：二选一 / 多选一，if-else适配范围判断，switch-case适配固定值匹配，switch 必须加break防止穿透；
2. 循环逻辑：重复执行，for知次数、while知结束条件、do-while至少执行一次，必须更新循环变量避免死循环；
3. 组合使用：循环负责 “重复遍历 / 执行”，分支负责 “条件判断筛选 / 选择”，是解决实际问题的核心思路；
4. 流程控制：break跳出当前循环 /switch，continue跳过本次循环继续下一次。

掌握以上内容，就能灵活使用 Java 的分支和循环逻辑，实现绝大多数基础业务功能（如计算器、遍历数据、菜单系统、猜数字游戏等）。