《Java 程序设计》第 3 章 - 选择与循环

啊阿狸不会拉杆

发布于 2026-01-21 12:44:13

130

大家好！今天我们来学习《Java 程序设计》的核心章节 ——选择与循环结构。在编程中，选择结构让程序能根据条件做出不同决策，循环结构则让程序能重复执行任务，这两类结构是实现复杂逻辑的基础。本文将从语法细节到实战案例，带大家全面掌握这部分知识。

思维导图

3.1 选择结构

选择结构的核心是 **“根据条件执行不同代码”**。Java 提供了多种选择语句，适应不同场景的需求。

3.1.1 单分支 if 语句

单分支 if 语句是最简单的选择结构，语法为：

if (条件表达式) {
    // 条件为true时执行的代码块
}

流程图

示例代码：判断成绩是否及格

import java.util.Scanner;

public class SingleIfDemo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入成绩：");
        int score = scanner.nextInt();

        // 单分支if：成绩>=60则提示及格
        if (score >= 60) {  // 条件表达式：结果为boolean类型
            System.out.println("恭喜，成绩及格！");  // 条件成立时执行
        }

        // 无论条件是否成立，都会执行后续代码
        System.out.println("成绩查询结束");
        scanner.close();
    }
}

代码说明：

条件表达式必须返回boolean值（true/false）
若代码块只有一行，可省略{}，但建议始终保留以提高可读性
常见应用：参数校验、权限判断等场景

3.1.2 双分支 if-else 语句

当需要根据条件执行 “二选一” 的逻辑时，使用 if-else 语句：

if (条件表达式) {
    // 条件为true时执行
} else {
    // 条件为false时执行
}

流程图

示例代码：判断奇偶数

import java.util.Scanner;

public class IfElseDemo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入一个整数：");
        int num = scanner.nextInt();

        // 双分支判断：num%2==0为偶数，否则为奇数
        if (num % 2 == 0) {
            System.out.println(num + "是偶数");
        } else {
            System.out.println(num + "是奇数");
        }

        scanner.close();
    }
}

应用场景：登录验证（成功 / 失败）、数值比较（大于 / 小于）等需要明确二元结果的场景。

3.1.3 嵌套的 if 语句和多分支 if-else 语句

当条件需要多层判断时，可使用嵌套 if；

当需要判断多个条件时，可使用多分支 if-else if-else。

嵌套 if 语句

语法结构：

if (条件1) {
    if (条件2) {
        // 条件1和条件2都成立时执行
    } else {
        // 条件1成立但条件2不成立时执行
    }
} else {
    // 条件1不成立时执行
}

多分支 if-else 语句

语法结构：

if (条件1) {
    // 条件1成立时执行
} else if (条件2) {
    // 条件1不成立但条件2成立时执行
} else if (条件3) {
    // 前两个条件不成立但条件3成立时执行
} else {
    // 所有条件都不成立时执行
}

流程图（多分支 if-else）

综合案例：成绩等级判断

import java.util.Scanner;

public class ScoreLevelDemo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入成绩（0-100）：");
        int score = scanner.nextInt();

        // 先验证成绩合法性（嵌套if）
        if (score >= 0 && score <= 100) {
            // 多分支判断等级
            if (score >= 90) {
                System.out.println("等级：A（优秀）");
            } else if (score >= 80) {
                System.out.println("等级：B（良好）");
            } else if (score >= 60) {
                System.out.println("等级：C（及格）");
            } else {
                System.out.println("等级：D（不及格）");
            }
        } else {
            System.out.println("输入错误！成绩必须在0-100之间");
        }

        scanner.close();
    }
}

注意事项：

多分支语句中，条件判断有顺序性，前面的条件成立后，后面的条件不再执行
嵌套 if 不宜过深（建议不超过 3 层），否则会降低代码可读性

3.1.4 条件运算符（三目运算符）

条件运算符是简化版的双分支 if-else，语法更简洁，格式为：

结果变量 = 条件表达式 ? 表达式1 : 表达式2;

若条件为true，结果为表达式 1 的值；否则为表达式 2 的值

示例代码：

public class ConditionalOperatorDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        // 用条件运算符求两数最大值
        int max = a > b ? a : b;
        System.out.println("最大值：" + max);  // 输出：20

        // 用条件运算符判断奇偶
        String result = a % 2 == 0 ? "偶数" : "奇数";
        System.out.println(a + "是" + result);  // 输出：10是偶数
    }
}

应用场景：简单的二元判断场景，如数值比较、状态标记等。复杂逻辑建议用 if-else。

3.1.5 switch 语句结构

switch 语句用于多值匹配场景（判断一个变量与多个常量的匹配关系），Java 7 + 支持 int、char、String、枚举等类型。

语法结构：

switch (表达式) {
    case 常量1:
        // 表达式等于常量1时执行
        break;  // 跳出switch
    case 常量2:
        // 表达式等于常量2时执行
        break;
    // ...更多case
    default:
        // 所有常量都不匹配时执行
}

流程图

示例代码：菜单选择功能

import java.util.Scanner;

public class SwitchDemo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("===== 菜单 =====");
        System.out.println("1. 查看个人信息");
        System.out.println("2. 修改密码");
        System.out.println("3. 退出系统");
        System.out.print("请选择功能（1-3）：");
        int choice = scanner.nextInt();

        switch (choice) {
            case 1:
                System.out.println("执行：查看个人信息");
                System.out.println("姓名：张三 | 年龄：20");
                break;  // 必须加break，否则会继续执行下一个case
            case 2:
                System.out.println("执行：修改密码");
                System.out.println("密码修改成功！");
                break;
            case 3:
                System.out.println("执行：退出系统");
                System.out.println("欢迎下次使用！");
                break;
            default:
                System.out.println("输入错误！请选择1-3");
        }

        scanner.close();
    }
}

注意事项：

case后的常量必须是字面量或 final 变量，且不能重复

若缺少break，会触发case 穿透（继续执行下一个 case 代码）

Java 12 + 支持switch表达式（可直接返回值），语法更简洁：

String result = switch (choice) {
    case 1 -> "查看信息";
    case 2 -> "修改密码";
    case 3 -> "退出系统";
    default -> "输入错误";
};

3.2 循环结构

循环结构用于重复执行一段代码，直到满足终止条件。Java 提供三种循环：while、do-while、for。

3.2.1 while 循环

while循环是最基础的循环结构，语法为：

while (循环条件) {
    // 循环体（重复执行的代码）
}

执行流程：先判断条件，若为true则执行循环体，重复此过程直到条件为false。

流程图

示例代码：计算 1-100 的和

public class WhileDemo {
    public static void main(String[] args) {
        int sum = 0;  // 存储总和
        int i = 1;    // 循环变量（从1开始）

        // 循环条件：i <= 100
        while (i <= 100) {
            sum += i;  // 累加i到sum
            i++;       // 循环变量自增（避免死循环）
        }

        System.out.println("1-100的和：" + sum);  // 输出：5050
    }
}

关键要素：

循环条件：控制循环是否继续的 boolean 表达式
循环变量：需在循环体中更新（否则可能导致死循环）
适用场景：循环次数不确定的场景（如用户输入验证）

3.2.2 do-while 循环

do-while循环与while的区别是先执行一次循环体，再判断条件，语法为：

do {
    // 循环体
} while (循环条件);

流程图

示例代码：用户输入验证

import java.util.Scanner;

public class DoWhileDemo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int age;

        // 至少执行一次输入操作
        do {
            System.out.print("请输入年龄（1-120）：");
            age = scanner.nextInt();
        } while (age < 1 || age > 120);  // 年龄不合法则重复输入

        System.out.println("您输入的年龄是：" + age);
        scanner.close();
    }
}

适用场景：需要至少执行一次的循环场景，如输入验证、菜单交互等。

3.2.3 for 循环

for循环将循环变量初始化、条件判断、变量更新整合在一行，适合循环次数明确的场景，语法为：

for (初始化语句; 循环条件; 更新语句) {
    // 循环体
}

执行流程：初始化语句→判断条件→执行循环体→更新语句→重复判断条件...

流程图

示例代码：打印 1-10 的偶数

public class ForDemo {
    public static void main(String[] args) {
        System.out.println("1-10的偶数：");
        // 初始化i=2，条件i<=10，每次+2（直接遍历偶数）
        for (int i = 2; i <= 10; i += 2) {
            System.out.print(i + " ");  // 输出：2 4 6 8 10
        }
    }
}

增强 for 循环（foreach）：用于遍历数组或集合，语法更简洁：

public class ForEachDemo {
    public static void main(String[] args) {
        String[] fruits = {"苹果", "香蕉", "橙子"};
        // 遍历数组中的每个元素
        for (String fruit : fruits) {
            System.out.println(fruit);
        }
    }
}

适用场景：固定次数的循环（如遍历数组、计数统计），代码更紧凑。

3.2.4 循环的嵌套

循环的嵌套指一个循环内部包含另一个循环，外层循环执行一次，内层循环执行完整一轮。

示例代码：打印 5 行 5 列的矩形星号图案

public class NestedLoopDemo {
    public static void main(String[] args) {
        // 外层循环控制行数（5行）
        for (int row = 1; row <= 5; row++) {
            // 内层循环控制每行的星号数（5列）
            for (int col = 1; col <= 5; col++) {
                System.out.print("* ");
            }
            // 每行结束后换行
            System.out.println();
        }
    }
}

输出结果：

应用场景：二维数据处理（如矩阵）、图形打印、多层级数据遍历等。

3.2.5 break 语句和 continue 语句

这两个语句用于控制循环流程：

break：立即终止当前循环，跳出循环体
continue：跳过本次循环剩余代码，直接进入下一次循环

示例代码：对比 break 和 continue

public class BreakContinueDemo {
    public static void main(String[] args) {
        System.out.println("演示break：");
        for (int i = 1; i <= 5; i++) {
            if (i == 3) {
                break;  // 当i=3时终止循环
            }
            System.out.print(i + " ");  // 输出：1 2
        }

        System.out.println("\n演示continue：");
        for (int i = 1; i <= 5; i++) {
            if (i == 3) {
                continue;  // 当i=3时跳过本次循环
            }
            System.out.print(i + " ");  // 输出：1 2 4 5
        }
    }
}

注意：在嵌套循环中，break默认只终止当前所在的内层循环。

3.3 示例学习：从实战中掌握语法

3.3.1 任意抽取一张牌

需求：随机生成一张扑克牌（包含花色和点数），如 “红桃 A”“黑桃 10” 等。

实现思路：

定义花色数组（红桃、黑桃、方块、梅花）和点数数组（A,2-10,J,Q,K）
使用Random生成两个随机索引（分别对应花色和点数）
通过索引获取对应值并拼接结果

完整代码：

import java.util.Random;

public class RandomCardDemo {
    public static void main(String[] args) {
        // 1. 定义花色和点数数组
        String[] suits = {"红桃", "黑桃", "方块", "梅花"};
        String[] ranks = {"A", "2", "3", "4", "5", "6", "7", 
                          "8", "9", "10", "J", "Q", "K"};

        // 2. 创建随机数生成器
        Random random = new Random();

        // 3. 生成随机索引（花色：0-3，点数：0-12）
        int suitIndex = random.nextInt(suits.length);  // 0-3的随机数
        int rankIndex = random.nextInt(ranks.length);  // 0-12的随机数

        // 4. 拼接结果并输出
        String card = suits[suitIndex] + ranks[rankIndex];
        System.out.println("随机抽取的牌是：" + card);  // 例如：黑桃7

        random = null;  // 释放资源
    }
}

关键技术：数组索引访问、Random类生成随机数、选择结构的隐式应用。

3.3.2 求最大公约数（GCD）

需求：输入两个正整数，求它们的最大公约数（能同时整除两个数的最大整数）。

实现思路：用辗转相除法：

若 b≠0，计算 a 除以 b 的余数 r
令 a=b，b=r，重复步骤 1 直到 b=0
此时 a 即为最大公约数

完整代码：

import java.util.Scanner;

public class GCDDemo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入第一个正整数：");
        int a = scanner.nextInt();
        System.out.print("请输入第二个正整数：");
        int b = scanner.nextInt();

        // 保存原始值用于输出（后续a和b会被修改）
        int num1 = a;
        int num2 = b;

        // 辗转相除法：当b不等于0时循环
        while (b != 0) {
            int r = a % b;  // 计算余数
            a = b;          // 更新a为b
            b = r;          // 更新b为余数
        }

        System.out.println(num1 + "和" + num2 + "的最大公约数是：" + a);
        scanner.close();
    }
}

运行示例：

关键技术：循环结构的条件控制、算术运算符应用。

3.3.3 打印输出若干素数

需求：打印 100 以内的所有素数（大于 1 的自然数，除了 1 和自身外不能被其他数整除）。

实现思路：

遍历 2-100 的所有数
对每个数 n，判断是否为素数（检查 2 到√n 是否有能整除 n 的数）
若没有则为素数，打印输出

完整代码：

public class PrimeNumberDemo {
    public static void main(String[] args) {
        int count = 0;  // 统计素数个数
        System.out.println("100以内的素数有：");

        // 遍历2-100的数（1不是素数）
        for (int n = 2; n <= 100; n++) {
            boolean isPrime = true;  // 标记是否为素数

            // 检查是否有因子（从2到√n）
            for (int i = 2; i <= Math.sqrt(n); i++) {
                if (n % i == 0) {  // 若能被i整除，则不是素数
                    isPrime = false;
                    break;  // 跳出内层循环
                }
            }

            // 若为素数则打印，每5个换一行
            if (isPrime) {
                System.out.print(n + "\t");
                count++;
                if (count % 5 == 0) {  // 每5个素数换行
                    System.out.println();
                }
            }
        }

        System.out.println("\n100以内共有" + count + "个素数");
    }
}

输出结果：

关键技术：循环嵌套、素数判断算法、break优化循环效率。

3.4 小结

本章学习了 Java 的核心控制结构，总结如下：

结构类型	核心语法	应用场景
选择结构	if/if-else/switch	根据条件执行不同逻辑
循环结构	while/do-while/for	重复执行代码块
流程控制	break（终止循环）、continue（跳过本次）	优化循环执行

重点注意事项：

选择结构中，if适合范围判断，switch适合多值匹配
循环结构中，for适合次数明确场景，while/do-while适合条件控制场景
循环嵌套时注意控制内层循环的终止条件，避免性能问题

编程练习

练习 1：判断闰年

需求：输入年份，判断该年是否为闰年（能被 4 整除且不能被 100 整除，或能被 400 整除）。

import java.util.Scanner;

public class LeapYearDemo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入年份：");
        int year = scanner.nextInt();

        // 闰年判断条件
        boolean isLeap = (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0);

        if (isLeap) {
            System.out.println(year + "是闰年");
        } else {
            System.out.println(year + "不是闰年");
        }

        scanner.close();
    }
}

练习 2：打印菱形图案

需求：使用循环嵌套打印 5 行菱形（由星号组成）。

public class DiamondDemo {
    public static void main(String[] args) {
        int rows = 5;  // 菱形行数（奇数）

        // 上半部分（3行）
        for (int i = 1; i <= (rows + 1) / 2; i++) {
            // 打印空格
            for (int j = 1; j <= (rows + 1) / 2 - i; j++) {
                System.out.print(" ");
            }
            // 打印星号
            for (int k = 1; k <= 2 * i - 1; k++) {
                System.out.print("*");
            }
            System.out.println();
        }

        // 下半部分（2行）
        for (int i = (rows - 1) / 2; i >= 1; i--) {
            // 打印空格
            for (int j = 1; j <= (rows + 1) / 2 - i; j++) {
                System.out.print(" ");
            }
            // 打印星号
            for (int k = 1; k <= 2 * i - 1; k++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

练习 3：猜数字游戏

需求：程序随机生成 1-100 的整数，用户反复猜测，程序提示 “太大” 或 “太小”，直到猜对为止，统计猜测次数。

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

public class GuessNumberGame {
    public static void main(String[] args) {
        Random random = new Random();
        Scanner scanner = new Scanner(System.in);

        // 生成1-100的随机数
        int target = random.nextInt(100) + 1;
        int guessCount = 0;  // 猜测次数
        int guessNum;        // 用户猜测的数字

        System.out.println("===== 猜数字游戏 =====");
        System.out.println("请猜一个1-100的整数：");

        // 循环猜测直到猜对
        do {
            guessNum = scanner.nextInt();
            guessCount++;  // 次数+1

            if (guessNum > target) {
                System.out.println("太大了！再试试：");
            } else if (guessNum < target) {
                System.out.println("太小了！再试试：");
            } else {
                System.out.println("恭喜猜对了！");
            }
        } while (guessNum != target);

        System.out.println("你共猜了" + guessCount + "次");
        scanner.close();
        random = null;
    }
}