方法定义与调用

本章定位：方法（Method）是对象的行为契约。理解方法签名的构成要素、方法重载的编译期静态绑定规则，以及可变参数的底层实现（数组语法糖）。方法重载是面试中"编译期多态"的核心考点。

方法：对象的行为

白歌在 Code Review 时指着小崔的代码说："你的类只有属性，没有方法——这叫贫血模型，只是 C 语言 struct 的 Java 翻译版。一个真正的 Java 对象应该既知道自己是什么（属性），也知道自己能做什么（方法）。"

方法是类中用于完成特定功能的代码块，Java 中所有可执行代码都在方法内部（或代码块内部）。

方法签名

方法签名由五个要素组成：

要素说明是否必须示例
修饰符控制访问权限和行为否（默认包级私有）public、private、static、final
返回类型方法执行后返回的数据类型是void、int、String、Employee
方法名标识符，小驼峰命名，动词开头是calculateSalary、findByName
参数列表调用方传入的数据（类型 + 变量名）否（空括号）(long id, String name)、(int... scores)
异常声明声明可能抛出的受检异常否throws IOException
// 完整方法签名示例
public static Employee findById(long id) throws IllegalArgumentException {
    //  修饰符    返回类型     方法名   参数列表           异常声明
    //  [public static] [Employee] [findById] ([long id]) [throws IllegalArgumentException]

    if (id <= 0) {
        throw new IllegalArgumentException("id 必须大于 0");
    }
    // ... 查找逻辑
    return new Employee(id, "未知", 0);
}

返回值：void 与 return

return 的两大作用

  1. 返回结果：将方法计算的结果返回给调用方
  2. 终止方法：立即结束方法的执行，return 之后的代码不会被执行
public class ReturnDemo {

    // 有返回值：必须每个执行路径都有 return
    public int max(int a, int b) {
        if (a > b) {
            return a;  // ① 返回结果 + ② 终止方法
        }
        return b;      // 如果 a <= b 走到这里
    }

    // void 方法：return 仅用于提前终止
    public void printIfPositive(int value) {
        if (value <= 0) {
            return;  // 提前退出，不打印
        }
        System.out.println("正数: " + value);
        // 这里不需要写 return，方法末尾自动返回
    }

    // ⚠️ 注意：void 方法也可以写 return，但不能带值
    // public void test() {
    //     return 5;  // ❌ 编译错误：不兼容的类型
    // }
}
返回类型return 用法调用方能否取得值
voidreturn;（可省略）否
基本类型return 值;是，必须与返回类型兼容
引用类型return 引用;（可为 null）是，返回引用（地址值）

方法调用与栈帧模型

每次方法调用都会在 JVM 栈上创建一个新的栈帧（Stack Frame）。栈帧包含：

  • 局部变量表：存储方法参数和局部变量
  • 操作数栈：执行字节码指令的临时计算区域
  • 动态链接：指向运行时常量池中该方法的符号引用
  • 返回地址：方法执行完后返回到调用方的位置

方法重载（Overload）

定义与规则

方法重载（Overload）是指在同一个类中，允许多个方法拥有相同的方法名，但参数列表必须不同（参数类型、个数、顺序至少有一项不同）。

重载规则说明
方法名相同所有重载方法的方法名必须一致
参数列表不同类型不同、个数不同、顺序不同（至少满足一项）
返回类型无关返回类型不同不能构成重载
修饰符无关public/private/static 等不影响重载
异常声明无关throws 的异常不同不影响重载

编译期静态绑定（Static Dispatch）

方法重载是编译期多态——调用哪个重载版本由编译器在编译期根据**参数的编译时类型（静态类型）**决定，而非运行时的实际类型。

public class OverloadBindingDemo {
    // 重载方法 1
    public void print(Object obj) {
        System.out.println("Object 版本");
    }
    // 重载方法 2
    public void print(String str) {
        System.out.println("String 版本");
    }

    public static void main(String[] args) {
        OverloadBindingDemo demo = new OverloadBindingDemo();

        String s = "hello";
        demo.print(s);       // 输出：String 版本 —— 编译时类型是 String

        Object o = "hello";
        demo.print(o);       // 输出：Object 版本 —— 编译时类型是 Object！
                             // 虽然运行时 o 实际指向 String，但重载只看编译时类型
    }
}

这一点常与**方法重写（Override，运行期多态）**对比考察，详见第 7 章。

可变参数（JDK 5+）

可变参数（varargs）允许方法接收零个或多个同类型参数。底层本质是数组的语法糖。

// 传统方式：需要先包装成数组
public int sum(int[] arr) {
    int total = 0;
    for (int num : arr) total += num;
    return total;
}
// 调用：sum(new int[]{1, 2, 3})  —— 麻烦！

// 可变参数方式：直接传值
public int sum(int... nums) {
    int total = 0;
    for (int num : nums) total += num;
    return total;
}
// 调用：sum(1, 2, 3)  —— 简洁！

可变参数规则表

规则说明示例
一个方法只能有一个可变参数否则编译器无法区分✅ void test(int... nums)
可变参数必须在参数列表的最后否则调用方无法确定边界✅ void test(String name, int... scores)
可变参数的实质是数组class 文件反编译可见 int[]System.out.println(nums.getClass()); → class [I
可接收零个参数此时 nums.length == 0sum() 合法，返回 0
可与重载配合注意歧义——精确匹配优先sum(int a) 比 sum(int... nums) 优先

完整示例：飞翔科技薪资计算器

场景

黄俪（前端转后端）在学习方法重载时很困惑："为什么同一个方法名可以有不同的参数？" 白歌让她实现一个薪资计算器，要求支持月薪制、年薪制、以及多笔奖金求和。

/**
 * 飞翔科技 —— 薪资计算器
 * 演示：方法重载、可变参数
 */
public class SalaryCalculator {

    /**
     * 重载版本 1：月薪制 —— 基本薪资 + 单笔年终奖
     * @param baseSalary 月基本薪资
     * @param yearEndBonus 年终奖
     * @return 年总收入
     */
    public double calculateAnnual(double baseSalary, double yearEndBonus) {
        System.out.println("【月薪制】基数=" + baseSalary + "，年终奖=" + yearEndBonus);
        return baseSalary * 12 + yearEndBonus;
    }

    /**
     * 重载版本 2：年薪制 —— 固定年薪（不分月薪/年终）
     * @param annualPackage 年薪总包
     * @return 年总收入
     */
    public double calculateAnnual(double annualPackage) {
        System.out.println("【年薪制】年薪总包=" + annualPackage);
        return annualPackage;
    }

    /**
     * 重载版本 3：月薪制 + 多笔季度奖金（使用可变参数）
     * @param baseSalary 月基本薪资
     * @param quarterlyBonuses 各季度奖金，可变个数
     * @return 年总收入
     */
    public double calculateAnnual(double baseSalary, double... quarterlyBonuses) {
        double bonusTotal = 0;
        for (double bonus : quarterlyBonuses) {
            bonusTotal += bonus;
        }
        System.out.println("【月薪制+季度奖】基数=" + baseSalary
            + "，季度奖金共" + quarterlyBonuses.length + "笔，合计=" + bonusTotal);
        return baseSalary * 12 + bonusTotal;
    }

    /**
     * 重载版本 4：带员工姓名的薪资计算（参数类型不同）
     * @param employeeName 员工姓名
     * @param baseSalary 月基本薪资
     * @param yearEndBonus 年终奖
     * @return 年总收入
     */
    public double calculateAnnual(String employeeName, double baseSalary, double yearEndBonus) {
        System.out.println("【" + employeeName + "】月薪制，基数=" + baseSalary + "，年终奖=" + yearEndBonus);
        return baseSalary * 12 + yearEndBonus;
    }
}

/**
 * 测试类
 */
public class SalaryTest {
    public static void main(String[] args) {
        SalaryCalculator calc = new SalaryCalculator();

        System.out.println("===== 飞翔科技薪资计算 =====\n");

        // 版本 2：年薪制（一个参数）
        double daXiangSalary = calc.calculateAnnual(600000);
        System.out.println("大翔年收入: " + daXiangSalary + "\n");

        // 版本 1：月薪制 + 年终奖（两个参数）
        double baiGeSalary = calc.calculateAnnual(35000, 80000);
        System.out.println("白歌年收入: " + baiGeSalary + "\n");

        // 版本 4：带员工姓名的月薪制（三个参数，第一个是 String）
        double xiaoCuiSalary = calc.calculateAnnual("小崔", 8000, 20000);
        System.out.println("小崔年收入: " + xiaoCuiSalary + "\n");

        // 版本 3：月薪制 + 可变季度奖金（两个 double + 可变参数）
        double huangLiSalary = calc.calculateAnnual(12000, 5000, 3000, 4000, 6000);
        System.out.println("黄俪年收入: " + huangLiSalary + "\n");

        // 可变参数可传零个 —— 调用版本 3
        double kongLanSalary = calc.calculateAnnual(15000);
        //  注意：这里调用的是版本 3（double, double...），不是版本 2
        //  因为可变参数可以接收零个参数，但当一个参数精确匹配时，优先匹配版本 2
        //  这里 calc.calculateAnnual(15000) 会匹配版本 2（单个 double）
        System.out.println("孔蓝年收入: " + kongLanSalary + "\n");
    }
}

运行输出：
===== 飞翔科技薪资计算 =====

【年薪制】年薪总包=600000.0
大翔年收入: 600000.0

【月薪制】基数=35000.0，年终奖=80000.0
白歌年收入: 500000.0

【小崔】月薪制，基数=8000.0，年终奖=20000.0
小崔年收入: 116000.0

【月薪制+季度奖】基数=12000.0，季度奖金共4笔，合计=18000.0
黄俪年收入: 162000.0

【年薪制】年薪总包=15000.0
孔蓝年收入: 180000.0

注意：calc.calculateAnnual(15000) 匹配的是版本 2（单个 double），而非版本 3（double, double...）。因为 Java 编译器遵循精确匹配优先原则——版本 2 只需匹配一个参数，版本 3 虽然也可以匹配（可变参数接收零个），但版本 2 更精确。

易错场景

反例一：返回类型不同不构成重载

// ❌ 错误：编译器认为这是重复的方法定义
public class OverloadError1 {
    public int calculate(int a) {
        return a * 2;
    }
    // ❌ 编译错误：已在类中定义了方法 calculate(int)
    public double calculate(int a) {
        return a * 2.0;
    }
}

纠正：返回类型不能区分重载，必须改变参数列表。

反例二：可变参数位置的歧义

// ❌ 错误：可变参数不在最后
public class VarargsError {
    // ❌ 编译错误：可变参数必须是最后一个参数
    // public void test(int... nums, String name) { }
}

// ❌ 错误：可变参数和方法重载产生歧义
public class VarargsAmbiguity {
    public void test(int... nums) {
        System.out.println("varargs");
    }
    public void test(int a, int b) {
        System.out.println("two ints");
    }
    // test(1, 2) 调用哪个？——两个都能匹配！
    // 实际上：精确匹配优先，test(1, 2) 会调用 (int, int) 版本
    // 但 test(1) 就能同时匹配两个 —— 编译器报错
}

反例三：void 方法使用返回值

// ❌ 错误：尝试获取 void 方法的返回值
public class VoidError {
    public void print() {
        System.out.println("hello");
    }

    public static void main(String[] args) {
        VoidError demo = new VoidError();
        // ❌ 编译错误：'void' 类型不允许在这里
        // int result = demo.print();

        // ✅ 正确：void 方法只能作为语句调用
        demo.print();
    }
}

方法调用栈帧深度解析

当我们运行如下代码时，JVM 栈的变化过程：

public class StackFrameDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int result = max(a, b);           // ← 断点 1：调用前
        System.out.println(result);       // ← 断点 4：返回后
    }

    public static int max(int x, int y) {
        return x > y ? x : y;             // ← 断点 2/3
    }
}

关键理解：每个线程都有自己独立的 JVM 栈。方法调用 = 压栈（push），方法返回 = 出栈（pop）。递归过深导致 StackOverflowError 就是因为栈空间被无数个栈帧填满了。

面试考点

Q1：方法重载（Overload）和方法重写（Override）有什么区别？

维度重载（Overload）重写（Override）
发生位置同一个类中父子类之间
参数列表必须不同必须相同（或协变）
返回类型可同可不同必须相同或子类型（协变）
多态类型编译期多态（静态绑定）运行期多态（动态绑定）
访问权限无要求子类权限不能比父类更严格
注解不需要@Override 推荐加

Q2：以下哪些构成重载？

// 原有方法
public void calculate(int a, double b) { }

// ① public int calculate(int a, double b)    —— ❌ 参数列表相同
// ② public void calculate(double a, int b)    —— ✅ 参数顺序不同
// ③ public void calculate(int a)              —— ✅ 参数个数不同
// ④ public void calculate(int x, double y)    —— ❌ 参数名不算，编译后只看类型
// ⑤ private void calculate(int a, double b)   —— ❌ 修饰符不影响

Q3：可变参数的底层实现是什么？有什么限制？

可变参数在编译后会被转换为数组。int... nums 在 class 文件中实际是 int[] nums。限制：① 一个方法最多一个可变参数；② 可变参数必须是最后一个参数；③ 与数组参数重载时容易产生歧义；④ 每次调用都会创建一个数组对象，有微小性能开销。

Q4：为什么说方法重载是"编译期多态"？

因为编译器在编译时就能根据参数列表的静态类型确定调用哪个重载版本，而不需要等到运行时。demo.print((Object) "hello") 必然调用 print(Object) 版本，demo.print("hello") 必然调用 print(String) 版本——这个决策在 .class 文件中就已经确定了。

小崔的笔记："方法重载就是同一个动词（方法名）搭配不同的宾语（参数列表）。编译器就像严格的语文老师——只认参数的类型和个数，不认返回类型和修饰符。可变参数本质是数组，只是让你少写两行代码。"