方法的重载

方法重载让同一方法名适应不同参数。

重载概念

什么是方法重载

同一类中，方法名相同但参数列表不同的多个方法。

// 重载：同名不同参数
public int add(int a, int b) {
    return a + b;
}

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

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

重载的作用

• 同一功能适应不同参数
• 提供灵活的调用方式
• 增强代码可读性

// 灵活调用
add(5, 3);          // 调用两参数版本
add(5, 3, 2);       // 调用三参数版本
add(5.5, 3.3);      // 调用double版本

重载规则

重载三要素

方法名相同，参数列表不同（必须），返回类型不限。

重载要求：
1. 方法名相同（必须）
2. 参数列表不同（必须）：
   - 参数数量不同
   - 参数类型不同
   - 参数顺序不同
3. 返回类型无关（可相同或不同）
4. 修饰符无关

参数数量不同

// 参数数量不同
public void print() {
    System.out.println("默认信息");
}

public void print(String msg) {
    System.out.println(msg);
}

public void print(String msg, int times) {
    for (int i = 0; i < times; i++) {
        System.out.println(msg);
    }
}

// 调用
print();                // 默认信息
print("Hello");         // Hello
print("Hello", 3);      // Hello Hello Hello

参数类型不同

// 参数类型不同
public int add(int a, int b) {
    return a + b;
}

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

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

// 调用
add(5, 3);           // 8（int）
add(5.5, 3.3);       // 8.8（double）
add("Hello", "World");  // "HelloWorld"（String）

参数顺序不同

// 参数顺序不同（类型不同时）
public void show(int a, String b) {
    System.out.println(a + ": " + b);
}

public void show(String b, int a) {
    System.out.println(b + ": " + a);
}

// 调用
show(1, "张三");     // 1: 张三
show("张三", 1);     // 张三: 1

不能构成重载的情况

返回类型不同不能重载

// 错误示例：只有返回类型不同
public int getNumber() {
    return 100;
}

// public double getNumber() {  // 编译错误：重复方法
//     return 100.0;
// }

// 返回类型不同不能构成重载

参数名称不同不能重载

// 错误示例：参数名称不同
public void print(int a) {
    System.out.println(a);
}

// public void print(int b) {  // 编译错误：参数类型相同
//     System.out.println(b);
// }

// 参数名称不影响重载判断

修饰符不同不能重载

// 错误示例：修饰符不同
public void method() {
}

// private void method() {  // 编译错误：参数相同
// }

// 修饰符不影响重载判断

重载调用匹配

编译器匹配规则

编译器根据参数类型选择最匹配的方法。

public void test(int a) {
    System.out.println("int: " + a);
}

public void test(double a) {
    System.out.println("double: " + a);
}

// 精确匹配优先
test(5);       // int: 5（精确匹配int）
test(5.0);     // double: 5.0（精确匹配double）

// 自动类型转换匹配
test(5L);      // double: 5.0（long转为double）

匹配优先级

匹配优先级：
1. 精确匹配
2. 类型转换匹配（ widening：int → long → float → double）
3. 自动装箱匹配（int → Integer）
4. 可变参数匹配

匹配示例

public void process(int a) {
    System.out.println("int");
}

public void process(Integer a) {
    System.out.println("Integer");
}

public void process(long a) {
    System.out.println("long");
}

process(5);       // 输出：int（精确匹配）
process(Integer.valueOf(5));  // 输出：Integer（精确匹配）
process(5L);      // 输出：long（精确匹配）

重载常见应用

构造方法重载

public class Student {
    String name;
    int age;
    
    // 无参构造
    public Student() {
        this.name = "默认";
        this.age = 18;
    }
    
    // 单参数构造
    public Student(String name) {
        this.name = name;
        this.age = 18;
    }
    
    // 全参数构造
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

// 灵活创建对象
Student s1 = new Student();
Student s2 = new Student("张三");
Student s3 = new Student("张三", 25);

打印方法重载

public void print(int num) {
    System.out.println("整数: " + num);
}

public void print(double num) {
    System.out.println("小数: " + num);
}

public void print(String str) {
    System.out.println("字符串: " + str);
}

public void print(int[] arr) {
    System.out.println("数组: " + Arrays.toString(arr));
}

// 调用
print(100);          // 整数: 100
print(3.14);         // 小数: 3.14
print("Hello");      // 字符串: Hello
print(new int[]{1,2,3});  // 数组: [1, 2, 3]

计算方法重载

public int max(int a, int b) {
    return a > b ? a : b;
}

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

public double max(double a, double b) {
    return a > b ? a : b;
}

// 调用
max(10, 20);           // 20
max(10, 20, 30);       // 30
max(10.5, 20.5);       // 20.5

可变参数与重载

可变参数重载

public int sum(int... nums) {
    int total = 0;
    for (int num : nums) {
        total += num;
    }
    return total;
}

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

// 调用
sum(1, 2);      // 优先匹配两参数版本：3
sum(1, 2, 3);   // 匹配可变参数：6
sum();          // 匹配可变参数：0

可变参数匹配规则

// 精确匹配优先于可变参数
sum(1, 2);      // 调用sum(int, int)，不是sum(int...)

// 可变参数作为兜底
sum(1, 2, 3);   // 没有三参数版本，调用可变参数

重载设计建议

合理使用重载

// 好的设计：参数自然扩展
public void show(String name) { }
public void show(String name, int age) { }
public void show(String name, int age, String address) { }

// 不好的设计：参数混乱
public void show(String a, int b) { }
public void show(int a, String b) { }  // 顺序颠倒，易混淆

避免歧义重载

// 可能产生歧义
public void test(int a, double b) { }
public void test(double a, int b) { }

// 调用歧义
// test(5, 5);  // 编译错误：两个方法都匹配
// 5可转为int或double，产生歧义

重载与重写对比

重载vs重写

要点总结

• 重载：同一类中方法名相同、参数不同
• 重载规则：参数数量、类型、顺序不同
• 返回类型不影响重载
• 修饰符不影响重载
• 参数名称不影响重载
• 编译器自动匹配最合适方法
• 精确匹配优先于类型转换
• 构造方法常用重载提供多种创建方式
• 可变参数可与其他方法重载
• 精确匹配优先于可变参数匹配
• 避免产生歧义的重载
• 重载与重写是不同概念