四：条件判断——让程序做选择

一、回顾与本篇目标

上一篇你学会了运算符——算术运算符（加减乘除）、比较运算符（大于、小于、等于）、逻辑运算符（并且、或者、取反）。你知道比较运算的结果是一个 boolean 值——true 或 false。

这些 true 和 false 有什么用？它们最大的用途就是让程序做选择。就像你在生活中每天做无数选择一样——如果下雨就带伞，如果红灯就停下，如果余额不足就提示充值。程序也需要这样的能力：根据某个条件是否成立，决定接下来执行哪段代码。

这就是条件判断。它是编程中最基本也最重要的控制结构之一。有了条件判断，程序就不再是“一条直线走到头”，而是有了分支、有了选择。

本篇的目标：

1. 掌握 if/else if/else 条件判断
2. 学会条件判断的嵌套
3. 掌握 switch/case 多分支选择
4. 学会三元运算符

二、最简单的条件判断：if

if 是英文“如果”的意思。它的语法很直观：如果某个条件成立，就执行某段代码。

基本语法

if (条件) {
    // 条件成立时执行的代码
}

• 条件：必须是一个 boolean 值（true 或 false），用小括号 ( ) 包裹。
• 代码块：用花括号 { } 包裹。当条件成立时，花括号里的所有代码会被执行。
• 如果条件不成立，花括号里的代码会被跳过，程序继续执行后面的代码。

最简单的例子

public class IfDemo {
    public static void main(String[] args) {
        int score = 85;

        if (score >= 60) {
            System.out.println("及格了！");
        }

        System.out.println("程序结束");
    }
}

输出：

及格了！
程序结束

如果把 score 改成 55：

程序结束

因为 score >= 60 的结果是 false，所以 if 里面的代码被跳过了。

如果代码块只有一行，花括号可以省略

if (score >= 60)
    System.out.println("及格了！");

但强烈建议始终使用花括号。省略花括号容易导致一种叫“悬空 else”的 bug——你以为 else 属于外层 if，实际上它属于内层 if。始终加花括号可以完全避免这种问题。

三、二选一：if…else

else 是“否则”的意思。如果条件成立，执行 if 的代码块；否则，执行 else 的代码块。

if (条件) {
    // 条件成立时执行
} else {
    // 条件不成立时执行
}

public class IfElseDemo {
    public static void main(String[] args) {
        int score = 55;

        if (score >= 60) {
            System.out.println("及格了！");
        } else {
            System.out.println("不及格，需要补考。");
        }

        System.out.println("程序结束");
    }
}

输出：

不及格，需要补考。
程序结束

这条岔路的两条分支只会走其中一条——要么走 if 分支，要么走 else 分支，不可能两条都走。

四、多选一：if…else if…else

生活中有很多不是“二选一”的情况——考试成绩可能是不及格、及格、良好、优秀。这时候需要多个条件分支。

注意：Java 中写“否则如果”用的是 else if（两个单词，中间有空格），和某些语言不同。

if (条件1) {
    // 条件1成立时执行
} else if (条件2) {
    // 条件1不成立，但条件2成立时执行
} else if (条件3) {
    // 条件1和2都不成立，但条件3成立时执行
} else {
    // 以上所有条件都不成立时执行
}

public class GradeDemo {
    public static void main(String[] args) {
        int score = 85;

        if (score >= 90) {
            System.out.println("等级：优秀");
        } else if (score >= 80) {
            System.out.println("等级：良好");
        } else if (score >= 70) {
            System.out.println("等级：中等");
        } else if (score >= 60) {
            System.out.println("等级：及格");
        } else {
            System.out.println("等级：不及格");
        }

        System.out.println("程序结束");
    }
}

输出：等级：良好

执行逻辑——非常关键：程序从上到下依次检查每个条件。第一个成立的条件会执行其对应的代码块，然后整个 if-else if-else 结构结束，后面的条件不再检查。

在上面的例子中：

1. 检查 score >= 90 → 85 不大于等于 90，不成立，跳过。
2. 检查 score >= 80 → 85 大于等于 80，成立！执行“良好”。
3. 后面的 score >= 70 虽然也成立，但不会被检查了。

条件的顺序很重要。如果把条件反过来写：

// 错误示范：条件顺序反了
if (score >= 60) {
    System.out.println("及格");
} else if (score >= 80) {
    System.out.println("良好");  // 永远不会执行！
}

因为 85 分首先满足 score >= 60，程序输出“及格”就结束了，根本不会去检查 score >= 80。所以条件应该从最严格到最宽松排列，或者从范围最小到范围最大排列。

五、条件判断的嵌套

在一个条件判断的代码块里，可以再写条件判断——这就像“如果……那么如果……”。

public class NestedIfDemo {
    public static void main(String[] args) {
        boolean hasTicket = true;
        int age = 12;

        if (hasTicket) {
            System.out.println("有票，可以入场。");

            // 嵌套的条件判断
            if (age >= 18) {
                System.out.println("可以观看所有影片。");
            } else if (age >= 12) {
                System.out.println("需要在家长陪同下观看 PG-13 影片。");
            } else {
                System.out.println("只能观看儿童影片。");
            }
        } else {
            System.out.println("请先购票。");
        }
    }
}

输出：

有票，可以入场。
需要在家长陪同下观看 PG-13 影片。

嵌套的层级不要太深——一般不超过 3 层。太深的嵌套会让代码难以阅读和理解。

六、switch/case——多分支选择的另一种写法

当需要根据一个变量的不同值来执行不同代码时，用 switch/case 比写一长串 if...else if 更清晰。

基本语法

switch (变量) {
    case 值1:
        // 当变量等于值1时执行
        break;
    case 值2:
        // 当变量等于值2时执行
        break;
    case 值3:
        // 当变量等于值3时执行
        break;
    default:
        // 以上所有 case 都不匹配时执行
        break;
}

完整示例

public class SwitchDemo {
    public static void main(String[] args) {
        int day = 3;

        switch (day) {
            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;
        }
    }
}

输出：星期三：一周过半

break 不能省略——穿透现象

这是 Java switch 语句最独特的特性：如果 case 后面没有 break，程序会继续执行下一个 case 的代码，直到遇到 break 或 switch 结束。这叫“穿透”（fall-through）。

这不是 bug，而是刻意设计的功能——有时候多个 case 需要共享同一段处理逻辑：

switch (day) {
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
        System.out.println("工作日，要上班");
        break;
    case 6:
    case 7:
        System.out.println("周末，休息！");
        break;
}

day 是 1、2、3、4、5 中的任何一个，都会穿透到 case 5 的代码块，输出“工作日，要上班”。这种写法比在每个 case 里重复写相同的代码要简洁。

如果你不是故意利用穿透，记得每个 case 后面写 break。

switch 支持的变量类型

switch 括号中的变量可以是：

• 整数类型：byte、short、int
• 字符类型：char
• 字符串类型：String（JDK 7 开始支持）
• 枚举类型：enum

不能使用 double、float、boolean。

// JDK 7+：switch 支持字符串
String fruit = "apple";

switch (fruit) {
    case "apple":
        System.out.println("这是苹果");
        break;
    case "banana":
        System.out.println("这是香蕉");
        break;
    default:
        System.out.println("未知水果");
        break;
}

七、三元运算符——简短的 if…else

当 if…else 结构非常简单（只是根据条件给一个变量赋值）时，可以用三元运算符写得更简洁。

变量 = 条件 ? 值1 : 值2;

如果条件成立，变量等于 值1；否则等于 值2。

int age = 20;

// 传统的 if...else 写法
String status;
if (age >= 18) {
    status = "成年";
} else {
    status = "未成年";
}

// 三元运算符写法（一行搞定）
String status2 = age >= 18 ? "成年" : "未成年";

System.out.println(status);   // 成年
System.out.println(status2);  // 成年

三元运算符适合简单的二选一赋值。如果逻辑复杂（多行代码、嵌套判断），还是用 if…else 更清晰。

// 三元运算符可以嵌套，但可读性变差——不建议
int score = 85;
String grade = score >= 90 ? "优秀" : score >= 80 ? "良好" : "其他";
// 这等价于：
// if (score >= 90) grade = "优秀";
// else if (score >= 80) grade = "良好";
// else grade = "其他";

八、综合演示：BMI 体重指数计算器

下面这个程序综合运用了输入、运算和条件判断，做一个简单的 BMI 计算器。注意：BMI 公式是 体重（kg）÷ 身高（m）²。为了简单，这里把身高和体重直接写在代码里。

public class BMICalculator {
    public static void main(String[] args) {
        // 身高（米）和体重（千克）
        double height = 1.75;
        double weight = 70.0;

        // 计算 BMI
        double bmi = weight / (height * height);

        // 输出基本信息
        System.out.println("========== BMI 计算器 ==========");
        System.out.println("身高：" + height + " 米");
        System.out.println("体重：" + weight + " 千克");
        System.out.println("BMI：" + bmi);

        // 根据 BMI 判断体重状态
        System.out.print("体重状态：");
        if (bmi < 18.5) {
            System.out.println("偏瘦");
        } else if (bmi < 24.0) {
            System.out.println("正常");
        } else if (bmi < 28.0) {
            System.out.println("偏胖");
        } else {
            System.out.println("肥胖");
        }

        // 给出建议
        System.out.print("健康建议：");
        if (bmi < 18.5) {
            System.out.println("建议增加营养摄入，适当增重。");
        } else if (bmi < 24.0) {
            System.out.println("体重正常，请继续保持！");
        } else {
            System.out.println("建议控制饮食，增加运动。");
        }

        System.out.println("================================");
    }
}

输出：

========== BMI 计算器 ==========
身高：1.75 米
体重：70.0 千克
BMI：22.857142857142858
体重状态：正常
健康建议：体重正常，请继续保持！
================================

九、常见错误和陷阱

1. 把赋值当成比较

int age = 20;
// if (age = 18) { ... }   // 编译错误！age = 18 是赋值，不是比较
// 正确写法：
if (age == 18) {
    System.out.println("年龄正好 18 岁");
}

Java 中 if (age = 18) 会直接编译报错——因为 age = 18 的结果是 int 类型 18，而 if 的条件要求 boolean 类型。这是 Java 比 C 语言更安全的地方——C 语言中这个错误会被悄悄放过去。

2. 字符串比较用 ==

String fruit = "apple";
// if (fruit == "apple") { ... }  // 危险！比较的是内存地址，不是内容
// 正确写法：
if (fruit.equals("apple")) {
    System.out.println("是苹果");
}

== 比较的是两个变量存的内存地址是否相同，equals() 比较的是字符串的内容是否相同。后面讲到字符串时会详细解释。

3. 条件顺序不对

前面已经提过，但值得再强调：条件从最严格的到最宽松的排列，避免后面的条件永远无法执行。

4. switch 忘记 break

Java 编译器不会提醒你忘了写 break，因为它也不知道你是不是故意要穿透。如果你发现 switch 语句执行了不该执行的代码，先检查每个 case 后面有没有 break。

十、本篇动手练习

练习 1：判断奇偶

新建 Practice4_1.java。声明一个整数变量，用 if…else 判断它是奇数还是偶数（提示：用取余运算 %）。打印判断结果。

练习 2：判断闰年

新建 Practice4_2.java。声明一个年份变量（如 2024），用 if…else 判断它是不是闰年。闰年规则：能被 4 整除但不能被 100 整除，或者能被 400 整除。打印判断结果。

练习 3：判断季节

新建 Practice4_3.java。声明一个月份变量（1-12），用 switch/case 判断这个月属于什么季节：3-5 月是春季，6-8 月是夏季，9-11 月是秋季，12、1、2 月是冬季。

练习 4：简单计算器

新建 Practice4_4.java。声明两个数字变量（如 10 和 3）和一个字符变量表示运算符（'+'、'-'、'*'、'/'）。用 if…else 判断运算符并执行对应的计算，打印结果。注意除数为 0 的情况。

十一、本篇小结

这一篇你学会了让程序做选择：

• if：如果条件成立，执行代码块。条件必须是 boolean 值，用括号包裹。
• if...else：二选一。条件成立走 if 分支，不成立走 else 分支。
• if...else if...else：多选一。从上到下检查条件，第一个成立的执行。条件顺序很重要——从最严格到最宽松排列。
• 嵌套条件判断：在一个条件判断内部再写条件判断。层数不宜过多。
• switch/case：多分支选择，适合判断一个变量等于几个固定值。每个 case 后面通常需要 break，除非故意利用穿透。
• 三元运算符：简短的二选一赋值——变量 = 条件 ? 值1 : 值2;。

条件判断让程序有了“智能”——能根据不同的情况做不同的事情。下一篇，我们学习循环——让程序能重复执行某段代码，处理大量数据。

下一篇预告

下一篇——《循环——让程序重复做事》：for 循环、while 循环、do...while 循环、break 和 continue 的用法、循环嵌套。你会写出能自动计算 1 到 100 之和的程序。

Java 零基础入门，每周更新。