Java基础全套教程（三）—— 控制语句、方法、递归算法

本章是Java编程从基础语法走向逻辑编程的核心转折点。前面我们学习了变量、数据类型、运算符，只能实现简单的顺序执行代码。而真正的程序，需要具备判断能力、重复执行能力、代码复用能力。

所有软件、系统、项目的底层逻辑，全部由三种流程结构 + 方法封装 + 递归思想构成。学好本章，才算真正具备写逻辑代码的能力，是入门编程的核心门槛。

3.1 程序三大执行流程

Java程序的执行顺序只有三种结构，所有复杂逻辑都是这三种结构的组合嵌套：

3.1.1 顺序结构

代码默认执行方式：从上往下、逐行执行、无跳转、无重复。简单的赋值、打印、运算都属于顺序结构。

3.1.2 选择结构（分支结构）

根据条件真假，选择性执行部分代码。核心思想：满足条件才执行，不满足则跳过或走其他分支。用于处理判断、筛选、状态区分场景。

3.1.3 循环结构

满足条件时，重复执行一段代码，直到条件不成立为止。用于批量处理、重复运算、遍历数据等场景。

---

3.2 选择结构详解（if / switch）

3.2.1 if 单分支结构

语法规则：仅在条件为 true 时执行代码块，条件为 false 直接跳过。

if(布尔表达式){
    // 条件成立才执行
}

开发强制规范：

1. 无论语句块只有一行还是多行，必须加大括号；

2. 不加大括号仅对下一行生效，极易产生隐藏bug。

全新示例：随机幸运数字判断

程序随机生成一个1~10的数字，判断是否为幸运数字（7、8、9为幸运）

public class LuckyNumTest {
    public static void main(String[] args) {
        // 生成1~10随机整数
        int num = (int)(Math.random() * 10) + 1;

        if(num >= 7){
            System.out.println("本次随机数：" + num + "，恭喜！今日幸运数字！");
        }
        if(num < 7){
            System.out.println("本次随机数：" + num + "，平常心，下次更好！");
        }
    }
}

3.2.2 if-else 双分支结构

语法逻辑：二选一执行，条件成立执行前者，不成立执行后者，必然执行其中一块。

if(布尔表达式){
    // 成立执行
}else{
    // 不成立执行
}

全新示例：体重标准判断

随机生成体重数值，判断是否属于标准体重范围

public class WeightJudgeTest {
    public static void main(String[] args) {
        // 随机生成40~80kg体重
        double weight = 40 + Math.random() * 40;
        System.out.println("当前体重：" + String.format("%.1f",weight) + "kg");

        // 假设60-70为标准体重
        if(weight >= 60 && weight <= 70){
            System.out.println("体重达标，身材标准！");
        }else{
            System.out.println("体重不在标准范围，记得合理运动！");
        }
    }
}

拓展：三元运算符替代双分支

public class TernaryTest {
    public static void main(String[] args) {
        int score1 = 76;
        int score2 = 89;
        // 获取两个分数中的较高值
        int maxScore = score1 > score2 ? score1 : score2;
        System.out.println("最高分：" + maxScore);
    }
}

3.2.3 if-else if-else 多分支结构

用于多区间、多等级判断，从上到下依次匹配，匹配成功立即结束分支，所有条件不匹配则走else默认分支。

全新示例：考试分数等级评定

随机生成0~100分数，按学业等级划分评级

public class ScoreLevelTest {
    public static void main(String[] args) {
        int score = (int)(Math.random() * 101);
        System.out.println("考试分数：" + score);

        if(score >= 90){
            System.out.println("评级：优秀A+");
        }else if(score >= 80){
            System.out.println("评级：良好A");
        }else if(score >= 70){
            System.out.println("评级：中等B");
        }else if(score >= 60){
            System.out.println("评级：及格C");
        }else{
            System.out.println("评级：不及格D，需要补考");
        }
    }
}

3.2.4 switch 多值匹配结构

switch 适合固定等值匹配，不适合区间判断，执行效率高于if多分支。

支持类型：byte、short、int、char、String、枚举

核心特点：缺少break会发生case穿透

全新示例1：星期日程匹配

public class SwitchWeekTest {
    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:
            case 7:
                System.out.println("周末：休息充电");
                break;
            default:
                System.out.println("星期参数错误");
        }
    }
}

全新示例2：String字符串匹配（JDK7+）

public class SwitchStringTest {
    public static void main(String[] args) {
        String fruit = "apple";
        switch (fruit){
            case "apple":
                System.out.println("苹果：富含维生素");
                break;
            case "banana":
                System.out.println("香蕉：补充能量");
                break;
            case "orange":
                System.out.println("橙子：润肺解渴");
                break;
            default:
                System.out.println("未知水果");
        }
    }
}

---

3.3 循环结构详解

3.3.1 while 循环（先判断、后执行）

条件不成立则一次都不执行，适合未知循环次数场景。

全新示例：计算1~100偶数总和

public class WhileEvenSumTest {
    public static void main(String[] args) {
        int i = 1;
        int evenSum = 0;
        while(i <= 100){
            if(i % 2 == 0){
                evenSum += i;
            }
            i++;
        }
        System.out.println("1~100偶数总和：" + evenSum);
    }
}

3.3.2 do-while 循环（先执行、后判断）

至少执行一次，适合人机交互、输入校验场景。

全新示例：模拟签到打卡（至少提示一次）

public class DoWhileSignTest {
    public static void main(String[] args) {
        int count = 1;
        do {
            System.out.println("今日第" + count + "次打卡成功");
            count++;
        } while (count <= 3);
    }
}

3.3.3 for 循环（开发首选）

结构紧凑、变量作用域可控，适合已知循环次数场景。

全新示例：输出1~100所有能被4整除的数

public class ForFourTest {
    public static void main(String[] args) {
        System.out.println("1~100能被4整除的数：");
        for(int i = 1; i <= 100; i++){
            if(i % 4 == 0){
                System.out.print(i + " ");
            }
        }
    }
}

3.3.4 嵌套循环

外层控行、内层控列，用于打印图形、批量双层遍历。

全新示例：打印6行6列星号矩阵

public class NestMatrixTest {
    public static void main(String[] args) {
        for(int i = 0; i < 6; i++){
            for(int j = 0; j < 6; j++){
                System.out.print("* ");
            }
            System.out.println();
        }
    }
}

全新九九乘法表（排版优化版）

public class MultiTableTest {
    public static void main(String[] args) {
        for(int row = 1; row <= 9; row++){
            for(int col = 1; col <= row; col++){
                System.out.printf("%d*%d=%-2d ",col,row,row*col);
            }
            System.out.println();
        }
    }
}

3.3.5 break 与 continue

break：终止当前整个循环

continue：跳过本次，直接进入下一次循环

全新break示例：寻找第一个能被7整除的数

public class BreakSevenTest {
    public static void main(String[] args) {
        for(int i = 10; i < 50; i++){
            if(i % 7 == 0){
                System.out.println("找到目标数：" + i);
                break;
            }
        }
    }
}

全新continue示例：跳过偶数，只输出奇数

public class ContinueOddTest {
    public static void main(String[] args) {
        for(int i = 1; i <= 30; i++){
            if(i % 2 == 0){
                continue;
            }
            System.out.print(i + " ");
        }
    }
}

---

3.4 方法（代码复用核心）

方法是具备独立功能的代码块，可以重复调用，解决代码冗余、杂乱问题，是面向对象的基础。

3.4.1 方法语法格式

修饰符 返回值类型 方法名(形参列表){
    方法体
    return 返回值;
}

3.4.2 基础方法示例（全新案例）

定义方法实现「计算两数乘积」和「打印欢迎语」

public class MethodBaseTest {
    public static void main(String[] args) {
        // 调用方法
        printWelcome();
        int res = getMultiply(9, 7);
        System.out.println("两数乘积结果：" + res);
    }

    // 无参无返回值
    public static void printWelcome(){
        System.out.println("欢迎使用方法工具类！");
    }

    // 有参有返回值
    public static int getMultiply(int a, int b){
        return a * b;
    }
}

3.4.3 方法重载

同一个类中，方法名相同、参数列表不同（个数/类型/顺序），与返回值、参数名无关。

全新重载示例：多类型求和工具

public class OverloadTest {
    public static void main(String[] args) {
        System.out.println("两整数和：" + sum(12,23));
        System.out.println("三整数和：" + sum(11,22,33));
        System.out.println("浮点和：" + sum(2.5,3.6));
    }

    public static int sum(int a,int b){
        return a + b;
    }
    public static int sum(int a,int b,int c){
        return a + b + c;
    }
    public static double sum(double a,double b){
        return a + b;
    }
}

重载误区总结：仅返回值不同、仅参数名不同，都不构成重载。

3.4.4 实战方法案例：考勤罚款系统（全新逻辑）

public class AttendFineTest {
    public static void main(String[] args) {
        double fine = calcFine(25, 8000);
        System.out.println("本次迟到罚款：" + fine + "元");
    }

    public static double calcFine(int lateMin, double monthSalary){
        double fineMoney = 0;
        double daySalary = monthSalary / 21.75;

        if(lateMin <= 5){
            System.out.println("轻微迟到，口头警告");
        }else if(lateMin <= 15){
            fineMoney = 50;
        }else if(lateMin <= 30){
            fineMoney = 150;
        }else if(lateMin < 60){
            fineMoney = daySalary / 2;
        }else{
            fineMoney = daySalary * 2;
        }
        return fineMoney;
    }
}

---

3.5 递归算法

递归核心：方法自己调用自己，适合拆解重复性子问题，常用于数学运算、遍历、搜索算法。

递归必备两点：递归头（终止条件）、递归体（递推逻辑）

全新示例：递归计算累加 1~n

public class RecursionSumTest {
    public static void main(String[] args) {
        int result = getTotal(50);
        System.out.println("1~50累加结果：" + result);
    }

    public static int getTotal(int n){
        // 递归头
        if(n == 1){
            return 1;
        }
        // 递归体
        return n + getTotal(n - 1);
    }
}

递归优缺点：代码简洁优雅，但会占用栈内存，层数过多容易栈溢出，复杂场景优先循环。

---

本章核心知识点总结

1. 程序三大结构：顺序、选择、循环，覆盖所有编程逻辑；

2. if 适合区间判断，switch 适合固定值匹配，注意 case 穿透问题；

3. while先判后执行、do-while至少执行一次、for循环为开发首选；

4. break结束整体循环，continue跳过本次循环；

5. 方法实现代码复用，重载提升方法兼容性；

6. 递归核心是自己调用自己，必须设置终止条件，慎用深层递归。