本文章没有找到对应的语言版本

判断语句

在编程中，判断语句让我们能够根据不同的条件执行不同的代码。生活中的判断无处不在：如果明天不下雨，我就去爬山；如果考试成绩及格，就奖励自己一顿大餐。程序中的判断也是如此——“只有满足对应的条件，对应的代码才能执行”。

判断流程图解

if语句

if语句是最基本的判断结构，格式如下：

if (关系表达式) {
    语句体;
}

执行流程：先计算关系表达式，如果为 true，执行大括号中的语句体；如果为 false，跳过语句体。

练习：体温测量仪

public class IfDemo1 {
    public static void main(String[] args) {
        double temp = 37.5;
        if (temp >= 38) {
            System.out.println("请自我隔离");
        }
        System.out.println("请继续工作");
    }
}

注意：temp = 37.5 不满足 >= 38 的条件，所以只输出"请继续工作"。

练习：游戏人物的血条

游戏角色最大生命值200，最低为1。键盘输入受到的伤害 damage 和恢复量 restore，计算当前生命值。

import java.util.Scanner;

public class HPManager {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int hp = 200;  // 初始血量
        final int MAX_HP = 200;
        final int MIN_HP = 1;
        
        System.out.print("请输入受到的伤害值：");
        int damage = sc.nextInt();
        hp -= damage;
        
        // 检查血量是否低于最低值
        if (hp < MIN_HP) {
            hp = MIN_HP;
        }
        
        System.out.print("请输入恢复血量值：");
        int restore = sc.nextInt();
        hp += restore;
        
        // 检查血量是否超过最大值
        if (hp > MAX_HP) {
            hp = MAX_HP;
        }
        
        System.out.println("当前血量为：" + hp);
    }
}

判断语句的细节

  1. 大括号写法：左大括号写在上一行末尾，右大括号独占一行
  2. 可省略大括号：语句体只有一行时，大括号可以省略（但不推荐，容易出错）
  3. 小括号后面不能加冒号：Java和Python不同，这里不能写分号
  4. 直接判断布尔变量：布尔类型变量可以直接放在小括号中
boolean flag = true;
if (flag) {  // 等价于 if (flag == true)
    System.out.println("条件成立");
}

if-else语句

当条件不满足时也希望执行某些操作，使用 if-else：

if (关系表达式) {
    语句体1;   // 条件成立执行这里
} else {
    语句体2;   // 条件不成立执行这里
}

练习：考试成绩

输入一个0-100之间的成绩，判断是否通过（>=60分算通过）。

import java.util.Scanner;

public class ScoreCheck {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入你的成绩（0-100）：");
        int score = sc.nextInt();
        
        // 先做范围校验
        if (score < 0 || score > 100) {
            System.out.println("输入的成绩不合法！");
        } else if (score >= 60) {
            System.out.println("恭喜你，通过了！");
        } else {
            System.out.println("很遗憾，没有通过。");
        }
    }
}

if-else if 多条件判断

当有多个条件需要逐个判断时，使用 if-else if 结构：

if (条件1) {
    语句体1;
} else if (条件2) {
    语句体2;
} else if (条件3) {
    语句体3;
} else {
    语句体N;  // 以上条件都不满足时执行
}

执行流程：从上到下依次判断，一旦某个条件成立，执行对应语句体后直接跳出整个结构，不再继续判断后续条件。

练习：成绩等级评定

import java.util.Scanner;

public class GradeLevel {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入成绩（0-100）：");
        int score = sc.nextInt();
        
        if (score < 0 || score > 100) {
            System.out.println("成绩不合法");
        } else 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("不及格");
        }
    }
}

练习：外卖优惠券

小明要点外卖，有两个平台可以选择：

  • 饱了么：全场九折
  • 美单：满30减10

小明准备点50块钱的外卖，帮他算算哪个平台更便宜。

public class FoodDiscount {
    public static void main(String[] args) {
        double total = 50.0;
        
        // 饱了么：打九折
        double baoleme = total * 0.9;
        
        // 美单：满30减10
        double meidan = total;
        if (total >= 30) {
            meidan = total - 10;
        }
        
        System.out.println("饱了么价格：" + baoleme + "元");
        System.out.println("美单价格：" + meidan + "元");
        
        if (baoleme < meidan) {
            System.out.println("选择饱了么更便宜");
        } else if (baoleme > meidan) {
            System.out.println("选择美单更便宜");
        } else {
            System.out.println("两个平台价格一样");
        }
    }
}

输出结果：

饱了么价格：45.0元
美单价格：40.0元
选择美单更便宜

switch语句

switch语句是多分支选择结构的另一种写法，适合做等值判断：

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

执行流程：

  1. 计算表达式的值
  2. 依次与每个 case 后面的值进行匹配
  3. 匹配成功则执行对应语句体，遇到 break 跳出
  4. 如果都不匹配，执行 default（默认分支）

注意：

  • 表达式类型可以是 byte、short、int、char、String（JDK7+）、枚举
  • break 不能省略，否则会产生 case 穿透（继续执行下一个case）
  • default 可以不写，但建议保留
import java.util.Scanner;

public class WeekDay {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入星期几（1-7）：");
        int day = sc.nextInt();
        
        switch (day) {
            case 1:
                System.out.println("星期一：Monday");
                break;
            case 2:
                System.out.println("星期二：Tuesday");
                break;
            case 3:
                System.out.println("星期三：Wednesday");
                break;
            case 4:
                System.out.println("星期四：Thursday");
                break;
            case 5:
                System.out.println("星期五：Friday");
                break;
            case 6:
                System.out.println("星期六：Saturday");
                break;
            case 7:
                System.out.println("星期日：Sunday");
                break;
            default:
                System.out.println("输入有误，请输入1-7！");
                break;
        }
    }
}

case穿透（fall-through）

如果某个case没有写 break，程序会继续执行下一个case的语句，直到遇到 break 或 switch 结束。利用这个特性可以简化代码：

// 判断工作日还是休息日
switch (day) {
    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;
}

for循环语句

循环语句用于重复执行某段代码。for循环是最常用的循环结构：

for (初始化语句; 条件判断语句; 条件控制语句) {
    循环体语句;
}

执行流程：

  1. 执行初始化语句（只执行一次）
  2. 执行条件判断语句，看结果是 true 还是 false
    • false：循环结束
    • true：执行循环体语句
  3. 执行条件控制语句
  4. 回到第2步继续判断
// 打印10次 "Hello"
for (int i = 0; i < 10; i++) {
    System.out.println("Hello");
}

练习：求1-100的和

public class SumFor {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum += i;
        }
        System.out.println("1-100的和为：" + sum);  // 5050
    }
}

练习：求1-100之间的偶数和

public class EvenSum {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                sum += i;
            }
        }
        System.out.println("1-100的偶数和为：" + sum);  // 2550
    }
}

练习：打印九九乘法表

public class MultiplicationTable {
    public static void main(String[] args) {
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(j + "*" + i + "=" + (j * i) + "\t");
            }
            System.out.println();  // 换行
        }
    }
}

输出：

1*1=1
1*2=2	2*2=4
1*3=3	2*3=6	3*3=9
...

while循环语句

while循环在不确定循环次数时特别好用：

初始化语句;
while (条件判断语句) {
    循环体语句;
    条件控制语句;
}

// for循环版：打印5次Hello
for (int i = 0; i < 5; i++) {
    System.out.println("Hello");
}

// while循环版：同样的效果
int i = 0;
while (i < 5) {
    System.out.println("Hello");
    i++;
}

练习：世界最高峰

珠穆朗玛峰高8844.43米（8844430毫米）。假设有一张足够大的纸，厚度0.1毫米。对折多少次后，纸的厚度能超过珠穆朗玛峰的高度？

public class Mountain {
    public static void main(String[] args) {
        double paper = 0.1;        // 纸的初始厚度（毫米）
        double mountain = 8844430; // 珠峰高度（毫米）
        int count = 0;             // 折叠次数
        
        while (paper < mountain) {
            paper *= 2;  // 对折一次，厚度翻倍
            count++;
        }
        
        System.out.println("需要折叠" + count + "次");
        System.out.println("最终厚度：" + paper + "毫米");
    }
}

答案：大约27次。这就是指数增长的威力！

do-while循环

do-while循环的特点是先执行一次循环体，再判断条件，所以循环体至少会执行一次：

初始化语句;
do {
    循环体语句;
    条件控制语句;
} while (条件判断语句);

int i = 1;
do {
    System.out.println("第" + i + "次执行");
    i++;
} while (i <= 5);

三种循环的对比：

循环类型特点适用场景
for格式紧凑，变量作用域在循环内明确知道循环次数
while先判断后执行不确定循环次数，依赖条件
do-while先执行后判断至少需要执行一次

循环控制语句

break — 跳出循环

break 用于终止当前循环，程序继续执行循环后面的代码。

// 找到1-100中第一个能被3和7同时整除的数
for (int i = 1; i <= 100; i++) {
    if (i % 3 == 0 && i % 7 == 0) {
        System.out.println("找到：" + i);  // 21
        break;  // 找到后立即跳出循环
    }
}

continue — 跳过本次循环

continue 用于跳过当前循环的剩余部分，直接进入下一次循环。

// 打印1-10中所有不是3的倍数的数
for (int i = 1; i <= 10; i++) {
    if (i % 3 == 0) {
        continue;  // 跳过3的倍数
    }
    System.out.print(i + " ");  // 1 2 4 5 7 8 10
}

综合练习：猜数字游戏

综合运用所学知识，写一个猜数字小游戏：

import java.util.Scanner;
import java.util.Random;

public class GuessNumber {
    public static void main(String[] args) {
        Random r = new Random();
        int target = r.nextInt(100) + 1;  // 1-100的随机数
        Scanner sc = new Scanner(System.in);
        int guess;
        int count = 0;
        
        System.out.println("=== 猜数字游戏 ===");
        System.out.println("我已经想好了一个1-100之间的数字，来猜猜看吧！");
        
        while (true) {
            System.out.print("请输入你猜的数字：");
            guess = sc.nextInt();
            count++;
            
            if (guess < 1 || guess > 100) {
                System.out.println("请输入1-100之间的数字！");
                continue;
            }
            
            if (guess > target) {
                System.out.println("猜大了，再试试！");
            } else if (guess < target) {
                System.out.println("猜小了，再试试！");
            } else {
                System.out.println("恭喜你猜对了！总共猜了" + count + "次");
                break;
            }
        }
    }
}

小结

本篇重点讲解了Java的流程控制语句：

语句类型关键字用途
判断语句if / else if / else根据条件选择执行路径
选择语句switch / case多分支等值匹配
循环语句for明确次数的循环
循环语句while依赖条件的循环
循环语句do-while至少执行一次的循环
控制语句break跳出循环
控制语句continue跳过本次循环

流程控制是编程的核心骨架，无论多么复杂的程序，本质上都是由"顺序、判断、循环"这三种基本结构组成的。下一篇我们将学习方法，把代码封装成可复用的功能模块。