Java 方法重载：相同方法名不同参数

在 Java 编程中，方法重载（Method Overloading）允许你在同一个类中定义多个同名方法，只要它们的参数列表不同。这能让你用统一的方法名处理不同类型或数量的输入，让代码更简洁、易读。

什么是方法重载？

方法重载的核心规则是：方法名相同，但参数列表必须不同。这里的“参数列表不同”指以下任一情况：

• 参数个数不同
• 参数类型不同
• 参数顺序不同（当类型不同时）

注意：仅返回值类型不同不算重载，Java 编译器会报错。

如何实现方法重载？

1. 在同一个类中，编写多个方法，使用相同的方法名。
2. 确保每个方法的参数列表与其他方法不同。例如：
   • print(int a)
   • print(String s)
   • print(int a, String s)
3. 调用时，Java 会根据传入的实际参数自动选择匹配的方法。

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }

    public double add(double a, double b) {
        return a + b;
    }

    public int add(int a, int b, int c) {
        return a + b + c;
    }
}

在上面的例子中，add 方法被重载了三次：

• 第一个接受两个 int
• 第二个接受两个 double
• 第三个接受三个 int

当你写 add(1, 2)，Java 调用第一个；写 add(1.5, 2.7)，调用第二个；写 add(1, 2, 3)，调用第三个。

常见错误与避坑指南

1. 不要只改返回值类型
   下面的代码无法编译：

   public int getValue() { return 1; }
   public double getValue() { return 1.0; } // ❌ 编译错误：重复方法

   因为参数列表完全相同，仅返回值不同，Java 无法区分。

2. 参数名不影响重载
   以下两个方法视为相同，会报错：

   public void log(String message) { }
   public void log(String text) { } // ❌ 错误：参数类型和数量相同，只是名字不同

3. 基本类型与包装类型可能引发歧义
   比如同时存在 method(int) 和 method(Integer)，当你传入 null 时，编译器可能无法确定调用哪个，导致编译错误。

实际应用场景

场景：打印不同类型的数据

你想写一个通用的打印方法，能处理整数、字符串、甚至数组。不用记多个方法名，只需调用 display(...) 即可。

public class Printer {
    public void display(int number) {
        System.out.println("整数: " + number);
    }

    public void display(String text) {
        System.out.println("文本: " + text);
    }

    public void display(int[] numbers) {
        System.out.print("数组: [");
        for (int i = 0; i < numbers.length; i++) {
            if (i > 0) System.out.print(", ");
            System.out.print(numbers[i]);
        }
        System.out.println("]");
    }
}

使用时：

Printer p = new Printer();
p.display(42);               // 输出：整数: 42
p.display("Hello");          // 输出：文本: Hello
p.display(new int[]{1,2,3}); // 输出：数组: [1, 2, 3]

Java 根据你传入的参数类型，自动选择最匹配的 display 方法。

重载 vs 重写（Overriding）的区别

虽然名字相似，但重载（Overloading）和重写（Overriding）完全不同：

例如，重写要求子类方法签名与父类完全一致：

class Animal {
    public void speak() {
        System.out.println("动物发声");
    }
}

class Dog extends Animal {
    @Override
    public void speak() { // ✅ 正确重写：参数列表相同
        System.out.println("汪汪");
    }
}

而重载是在 Dog 类内部再加一个 speak(String sound)，属于重载。

编译器如何选择重载方法？

当你调用一个重载方法时，Java 编译器按以下优先级匹配：

1. 精确匹配：参数类型完全一致。
2. 自动类型提升：如 byte → short → int → long → float → double。
3. 自动装箱/拆箱：如 int ↔ Integer。
4. 可变参数（varargs）：作为最后选择。

例如：

public void test(int a) { }
public void test(long a) { }
public void test(Integer a) { }
public void test(int... a) { }

调用 test(10) 时，优先选择 test(int a)，因为它是精确匹配。

但如果只有 test(long a) 和 test(Integer a)，test(10) 会选择 test(long a)，因为基本类型的自动提升优先于装箱。

最佳实践建议

1. 保持语义一致
   所有重载方法应完成相似的功能。不要让 save(String) 表示保存文件，而 save(int) 表示删除记录。

2. 避免过多重载
   如果一个方法有超过 4–5 个重载版本，考虑是否该用构建器模式或参数对象替代。

3. 优先使用清晰的方法名
   如果功能差异较大，不如用不同名字（如 parseDate 和 parseTime），比强行重载更易理解。

4. 文档注释每个重载版本
   在 Javadoc 中说明每个重载方法的用途和参数含义，方便他人调用。

验证你的重载是否合法

检查清单：

1. 所有重载方法是否在同一个类中？
2. 是否至少有一个方法的参数个数、类型或顺序与其他不同？
3. 是否没有仅靠返回值或参数名区分的方法？
4. 调用时是否能明确推断出唯一匹配的方法？（避免歧义）

如果全部满足，你的重载就是安全有效的。

public class Example {
    public void process(String input) { }
    public void process(String input, boolean flag) { }
    public void process(int id, String input) { }
    // ✅ 合法重载：参数列表均不同
}