9.5 方法重载

方法重载的概念

方法重载（Method Overloading）是指在同一个类中定义多个同名方法，但它们的参数列表不同（参数类型、参数数量或参数顺序不同）。方法重载是 Java 中实现多态的一种方式。

方法重载的条件

要实现方法重载，必须满足以下条件：

1. 方法名相同：所有重载的方法必须具有相同的方法名
2. 参数列表不同：参数列表必须在以下方面有所不同：
   • 参数数量不同
   • 参数类型不同
   • 参数顺序不同（当参数类型不同时）
3. 返回类型可以不同：返回类型可以相同也可以不同
4. 修饰符可以不同：修饰符可以相同也可以不同

方法重载的示例

示例 1：参数数量不同

public class OverloadingExample1 {
    public static void main(String[] args) {
        // 调用不同参数数量的方法
        System.out.println(add(5, 3)); // 调用两个参数的 add 方法
        System.out.println(add(5, 3, 2)); // 调用三个参数的 add 方法
    }
    
    // 两个参数的 add 方法
    public static int add(int a, int b) {
        return a + b;
    }
    
    // 三个参数的 add 方法
    public static int add(int a, int b, int c) {
        return a + b + c;
    }
}

示例 2：参数类型不同

public class OverloadingExample2 {
    public static void main(String[] args) {
        // 调用不同参数类型的方法
        System.out.println(add(5, 3)); // 调用 int 类型参数的 add 方法
        System.out.println(add(5.5, 3.5)); // 调用 double 类型参数的 add 方法
    }
    
    // int 类型参数的 add 方法
    public static int add(int a, int b) {
        return a + b;
    }
    
    // double 类型参数的 add 方法
    public static double add(double a, double b) {
        return a + b;
    }
}

示例 3：参数顺序不同

public class OverloadingExample3 {
    public static void main(String[] args) {
        // 调用不同参数顺序的方法
        System.out.println(printInfo("John", 25)); // 先 String 后 int
        System.out.println(printInfo(25, "John")); // 先 int 后 String
    }
    
    // 先 String 后 int 的 printInfo 方法
    public static String printInfo(String name, int age) {
        return "Name: " + name + ", Age: " + age;
    }
    
    // 先 int 后 String 的 printInfo 方法
    public static String printInfo(int age, String name) {
        return "Age: " + age + ", Name: " + name;
    }
}

方法重载的应用场景

1. 提供不同的参数选项：允许方法接受不同类型或数量的参数
2. 简化方法调用：使用相同的方法名，但根据参数自动选择合适的方法
3. 提高代码可读性：使用相同的方法名表示相同的功能，提高代码的可读性
4. 支持默认参数：通过重载实现类似默认参数的功能

方法重载的规则

1. 方法名必须相同：所有重载的方法必须具有相同的方法名
2. 参数列表必须不同：参数列表必须在参数数量、类型或顺序上有所不同
3. 返回类型可以不同：返回类型不影响方法重载的判断
4. 修饰符可以不同：修饰符不影响方法重载的判断
5. 异常列表可以不同：异常列表不影响方法重载的判断

方法重载的解析

当调用重载的方法时，Java 编译器会根据以下步骤选择合适的方法：

1. 精确匹配：寻找与参数类型完全匹配的方法
2. 自动类型转换：寻找可以通过自动类型转换匹配的方法
3. 可变参数：如果没有找到前两种匹配，寻找可变参数的方法
4. 编译错误：如果没有找到匹配的方法，编译错误

示例：方法重载的综合应用

public class OverloadingApplication {
    public static void main(String[] args) {
        // 调用不同的 print 方法
        print("Hello, Java!"); // 调用 String 参数的 print 方法
        print(42); // 调用 int 参数的 print 方法
        print(3.14); // 调用 double 参数的 print 方法
        print(true); // 调用 boolean 参数的 print 方法
        print(new int[]{1, 2, 3, 4, 5}); // 调用 int[] 参数的 print 方法
    }
    
    // 打印字符串
    public static void print(String message) {
        System.out.println("String: " + message);
    }
    
    // 打印整数
    public static void print(int number) {
        System.out.println("Integer: " + number);
    }
    
    // 打印浮点数
    public static void print(double number) {
        System.out.println("Double: " + number);
    }
    
    // 打印布尔值
    public static void print(boolean value) {
        System.out.println("Boolean: " + value);
    }
    
    // 打印数组
    public static void print(int[] array) {
        System.out.print("Array: ");
        for (int element : array) {
            System.out.print(element + " ");
        }
        System.out.println();
    }
}

方法重载与构造方法

构造方法也可以重载，允许创建对象时使用不同的参数组合。

示例：

public class Person {
    private String name;
    private int age;
    private String address;
    
    // 无参构造方法
    public Person() {
        this.name = "Unknown";
        this.age = 0;
        this.address = "Unknown";
    }
    
    // 一个参数的构造方法
    public Person(String name) {
        this.name = name;
        this.age = 0;
        this.address = "Unknown";
    }
    
    // 两个参数的构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        this.address = "Unknown";
    }
    
    // 三个参数的构造方法
    public Person(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }
    
    // 打印信息
    public void printInfo() {
        System.out.println("Name: " + name + ", Age: " + age + ", Address: " + address);
    }
}

public class PersonExample {
    public static void main(String[] args) {
        // 使用不同的构造方法创建对象
        Person person1 = new Person();
        Person person2 = new Person("John");
        Person person3 = new Person("John", 25);
        Person person4 = new Person("John", 25, "New York");
        
        // 打印信息
        person1.printInfo();
        person2.printInfo();
        person3.printInfo();
        person4.printInfo();
    }
}

常见问题

1. 方法重载的条件不满足

症状：编译错误：error: method methodName is already defined in class ClassName

解决方案：确保重载的方法参数列表不同

2. 方法重载的解析歧义

症状：编译错误：error: reference to methodName is ambiguous

解决方案：确保方法重载没有歧义，避免多个方法都可以匹配同一个调用

3. 混淆方法重载和方法覆盖

症状：代码逻辑错误

解决方案：了解方法重载和方法覆盖的区别：

• 方法重载：在同一个类中，方法名相同，参数列表不同
• 方法覆盖：在子类中，方法名、参数列表和返回类型都相同

总结

方法重载是 Java 中实现多态的一种方式，它允许在同一个类中定义多个同名方法，但它们的参数列表不同。方法重载的条件包括：

• 方法名相同
• 参数列表不同（参数数量、类型或顺序不同）
• 返回类型可以不同
• 修饰符可以不同

方法重载的应用场景包括：

• 提供不同的参数选项
• 简化方法调用
• 提高代码可读性
• 支持默认参数

通过合理使用方法重载，可以使代码更加灵活和易于使用。