Java基础快速入门条件控制

2026-06-23 10:08:40 作者：Wang's Blog

在Java中,条件控制是编程中非常基础且重要的概念,它允许程序根据不同的条件执行不同的代码块,Java中的条件控制主要通过if语句、else语句、else if语句以及switch语句来实现,本文给大家介绍Java基础快速入门条件控制,感兴趣的朋友一起看看吧

流程控制语句概述

在 Java 中，程序默认是按照代码的先后顺序从上到下依次执行的，但实际业务往往需要根据条件选择不同分支或重复执行某些操作。

流程控制语句就是用来控制程序执行方向的结构，主要分为顺序结构、分支结构和循环结构三大类。其中分支结构又包括 if 系列语句和 switch 语句。

顺序结构

顺序结构是 Java 程序默认的执行流程，代码按照编写的先后顺序，从上到下、从左到右依次执行，没有特定的语法结构。

任何 Java 程序都是从 main 方法的第一条语句开始，逐行向下运行，直到方法结束。即使程序被重复执行多次，执行顺序也不会发生变化。

下面是一个简单的顺序结构示例：

public class Demo1 {
    public static void main(String[] args) {
        System.out.println(1);
        System.out.println(2);
        System.out.println(3);
        System.out.println(4);
        System.out.println(5);
    }
}

无论运行多少次，控制台都会严格按照 1、2、3、4、5 的顺序输出。

if 语句格式一：单分支判断

if 语句的第一种格式是最基础的条件判断，对应中文中的“如果……就……”。其结构为 if (关系表达式) { 语句体; }。

程序会先计算关系表达式的结果，若结果为 true 则执行大括号中的语句体；若结果为 false 则跳过语句体，直接执行 if 之后的其他代码。

public class Demo1If {
    public static void main(String[] args) {
        System.out.println("开始");
        int age = 17;
        if(age >= 18){
            System.out.println("可以上网吧");
        }
        System.out.println("结束");
    }
}

注意事项：

如果 if 控制的语句体只有一条语句，大括号可以省略，但强烈不建议这样做，因为容易在修改代码时引入错误，例如定义变量会被编译器视为两条语句。
if 的小括号后面不要加分号，否则会把 if 和后面的语句体割裂开，导致条件不生效。

if 语句格式二：双分支 if-else

if-else 格式对应“如果……否则……”，结构为 if (关系表达式) { 语句体1; } else { 语句体2; }。

程序先计算关系表达式，结果为 true 时执行语句体1，为 false 时执行语句体2，两个语句体互斥，只会执行其中一个。

public class Demo2If {
    public static void main(String[] args) {
        int num = 9;
        if(num % 2 == 0){
            System.out.println("偶数");
        }else{
            System.out.println("奇数");
        }
    }
}

这段代码通过取模运算判断一个数是奇数还是偶数，num 对 2 取余为 0 则打印偶数，否则打印奇数。

if 语句格式三：多分支 if-else if-else

当需要判断多个条件时，使用 if-else if-else 结构，格式为多层 if (判断条件1) { … } else if (判断条件2) { … } … else { … }。程序从上到下依次检查每一个判断条件，一旦某个条件为 true，就执行对应的语句体并结束整个 if 结构；如果所有条件都不满足，则执行最后的 else 代码块。

public class Demo3If {
    public static void main(String[] args){
        int score = -1;
        if(score >= 90 && score <= 100){
            System.out.println("优秀");
        }else if (score >= 80 && score <= 89){
            System.out.println("良好");
        }else if (score >= 70 && score <= 79){
            System.out.println("中等");
        }else if (score >= 60 && score <= 69){
            System.out.println("及格");
        }else if (score >= 0 && score <= 59){
            System.out.println("请努力加油");
        }else{
            System.out.println("成绩有误!");
        }
    }
}

该示例根据学生成绩给出评价，并利用最后的 else 捕获不在 0~100 范围内的错误输入。
else 即使省略也不会报错，但加上它可以提供友好的错误提示，因此建议保留。

案例：考试奖励（if 嵌套）

实际开发中经常需要在一个 if 或 else 代码块内部继续编写 if 语句，即 if 的嵌套。
下面以一个根据成绩发放不同奖励的案例来演示：

import java.util.Scanner;
public class Test {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您的成绩:");
        int score = sc.nextInt();
        if(score >= 0 && score <= 100){
            if(score >= 95 && score <= 100){
                System.out.println("自行车一辆");
            }else if(score >= 90 && score <= 94){
                System.out.println("游乐场一次");
            }else if(score >= 80 && score <= 89){
                System.out.println("变形金刚一个");
            }else {
                System.out.println("挨顿揍, 这座城市又多了一个伤心的人~");
            }
        }else{
            System.out.println("您的成绩输入有误!");
        }
    }
}

程序首先通过 Scanner 获取学生成绩，然后使用外层 if-else 判断成绩是否在合法范围 0~100 之间。如果合法，再通过内层的 if-else if-else 判断具体分数段并给出对应奖励；如果非法，则直接提示输入错误。这种 if 嵌套写法可以让逻辑层次清晰，便于维护。

switch 语句

1 ) 基本格式与执行流程

switch 语句也是一种多分支选择结构，适合处理值匹配的场景。

其基本格式为：

switch(表达式) {
    case 值1:
        语句体1;
        break;
    case 值2:
        语句体2;
        break;
    ...
    default:
        语句体n+1;
        break;
}

表达式可以是 byte、short、int、char，JDK5 之后支持枚举，JDK7 之后支持 String
执行时先计算表达式的值，然后从上到下依次与每个 case 后面的常量值进行匹配
匹配成功则执行对应语句体，遇到 break 跳出整个 switch；如果所有 case 都不匹配，则执行 default 块中的语句体

2 ) default 的作用与建议

default 类似于 if-else 中的最后 else，用来处理所有 case 都无法匹配的情况
default 可以省略不写，但强烈建议保留，以便对范围外的值给出友好提示

注意事项

case 后面的值不允许重复，否则编译器直接报错
case 后面的值必须是常量，不能是变量

3 ) 案例：减肥计划

① 需求背景

现代人越来越注重健康管理，许多人会制定一周的运动计划，不同日子安排不同的锻炼项目。
例如：周一跑步、周二游泳、周三慢走、周四动感单车、周五爬山、周六拳击、周日好好吃一顿犒劳自己。
我们希望编写一个程序，用户输入 1~7 之间的整数（代表星期几），程序就能自动显示当天的推荐运动。

② 实现分析

使用 Scanner 从键盘读取一个整数，表示星期数。
将该整数作为 switch 表达式的匹配值。
使用 case 1 到 case 7 分别对应星期一至星期日的运动安排。
每个 case 内部输出对应的运动名称，然后用 break 结束 switch。
增加 default 分支，处理输入不在 1~7 范围的情况，给出“输入有误”的提示。

③ 完整代码

import java.util.Scanner;
public class WeightLossPlan {
    public static void main(String[] args) {
        // 第一步：键盘录入星期数据
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入星期数（1-7）：");
        int week = sc.nextInt();
        // 第二步：使用 switch 匹配并输出减肥计划
        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("您的输入有误，请输入1~7之间的整数");
                break;
        }
    }
}

执行流程说明

当用户输入 3 时，week 的值为 3，switch 从上到下匹配，case 1、2 不匹配，case 3 匹配成功，执行 System.out.println(“慢走”)，然后遇到 break 跳出 switch，程序结束
当用户输入 8 时，所有 case 都不匹配，执行 default 分支，输出错误提示

4 ） case 穿透现象与应用

① 什么是 case 穿透

在 switch 语句中，如果某个 case 分支的代码块中没有编写 break 语句，程序在执行完该 case 的代码后并不会自动跳出 switch 结构，而是会继续执行下一个 case 分支的代码，无论下一个 case 的值是否与表达式匹配。

这种现象被称为 case 穿透。穿透会一直持续下去，直到遇到 break 语句或整个 switch 执行完毕才会停止。

通过一个错误示例来直观感受穿透现象：

public class SwitchDemo {{
    public static void main(String[] args) {{
        char expression = 'b';
        switch(expression){{
            case 'a':
                System.out.println("A");
                break;
            case 'b':
                System.out.println("B");
                // 注意：这里故意没有写 break 
            case 'c':
                System.out.println("C");
            case 'd':
                System.out.println("D");
        }}
    }}
}}

运行后控制台输出 B、C、D。因为表达式匹配到 case ‘b’ 后打印了 B，但由于缺少 break，程序继续向下穿透，依次执行了 case ‘c’ 和 case ‘d’ 的打印语句。

② 利用 case 穿透合并分支

虽然忘记 break 常常导致意外的错误，但合理利用穿透反而能让代码更简洁。当多个 case 需要执行相同的逻辑时，可以通过省略 break 把这些 case 合并在一起，避免重复编写相同的语句体。

需求：键盘录入星期数，1 到 5 输出“工作日”，6 或 7 输出“休息日”，其他数字提示输入有误。

import java.util.Scanner;
public class SwitchDemo {{
    public static void main(String[] args) {{
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入星期数:");
        int week = sc.nextInt();
        switch(week){{
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
                System.out.println("工作日");
                break;
            case 6:
            case 7:
                System.out.println("休息日");
                break;
            default:
                System.out.println("您的输入有误");
                break;
        }}
    }}
}}

当 week 的值为 1 时，程序匹配到 case 1 但后面没有语句也没有 break，于是穿透到 case 2，依次向下直到 case 5，执行“工作日”的打印语句后遇到 break 结束。

这种写法把周一至周五这五个分支合并到了一起，省去了重复代码。

③ 再举一个判断元音字母的例子：

public class TestVowel {{
    public static void main(String[] args) {{
        // 随机生成 a~z 之间的一个小写字母 
        char c = (char)(Math.random() * 26 + 'a');
        switch(c){{
            case 'a':
            case 'e':
            case 'i':
            case 'o':
            case 'u':
                System.out.println(c + " 是元音字母");
                break;
            default:
                System.out.println(c + " 不是元音字母");
                break;
        }}
    }}
}}

程序随机生成一个字母，利用 case 穿透将 a、e、i、o、u 五个分支合并，只要满足任意一个元音字母就打印对应信息，非常简洁。

④ case 穿透的实际意义

合理使用 case 穿透可以达到以下效果：一是减少重复代码，提高代码的简洁性；二是清晰表达多个条件对应同一结果的业务逻辑，增强代码的可读性。

但需要特别注意，穿透必须是有意为之，应在相关 case 附近做好注释说明，避免后期维护人员误认为是遗漏了 break。

总结

switch 语句是 Java 中常用的多分支选择结构，适用于对离散值进行等值匹配的场景。
其核心要点总结如下：

格式组成：由 switch(表达式)、case 常量值、语句体、break 和可选的 default 构成。
表达式类型：支持 byte、short、int、char、枚举(JDK5)以及 String(JDK7)。
执行流程：计算表达式值，从上到下依次与 case 常量匹配，匹配成功则执行对应语句体，遇到 break 跳出整个 switch。
default 分支：所有 case 都不匹配时执行，虽然可以省略，但建议保留以处理非法输入。
case 穿透：省略 break 会导致匹配成功后继续执行后续 case 的代码。可利用这一特性将多个分支合并，减少重复代码，但必须有意识地使用并在代码中做好说明。

掌握好 switch 语句及其穿透特性，能够让我们在面对多分支数值匹配问题时编写出更加简洁、优雅的代码。

到此这篇关于Java基础快速入门条件控制的文章就介绍到这了,更多相关java条件控制内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

Java 条件控制与循环控制实例