方法重载（Method Overloading）详解

什么是方法重载？

方法重载是指在一个类中，可以定义 多个同名的方法 ，但这些方法的参数列表（参数的类型、数量、顺序）必须不同。方法重载的目的是为了提高代码的灵活性和可读性，使得同一个方法名可以处理不同类型或数量的参数。

方法重载的规则

1. 方法名相同：所有重载的方法必须有相同的方法名。
2. 参数列表不同：重载的方法必须有不同的参数列表，可以是参数的类型不同、参数的数量不同、参数的顺序不同。
3. 返回类型可以相同或不同：返回类型不影响方法的重载。
4. 访问修饰符可以不同：访问修饰符（如 public, private, protected）不影响方法的重载。

示例代码

下面是一个简单的示例，展示了如何在Java中使用方法重载：

public class MethodOverloadingExample {
    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        
        // 调用不同的 add 方法
        System.out.println(calculator.add(5, 3));           // 输出: 8
        System.out.println(calculator.add(5.5, 3.3));       // 输出: 8.8
        System.out.println(calculator.add(5, 3, 2));        // 输出: 10
    }
}

class Calculator {
    // 重载的 add 方法，接受两个 int 参数
    public int add(int a, int b) {
        return a + b;
    }
    
    // 重载的 add 方法，接受两个 double 参数
    public double add(double a, double b) {
        return a + b;
    }
    
    // 重载的 add 方法，接受三个 int 参数
    public int add(int a, int b, int c) {
        return a + b + c;
    }
}

详细解释

1. 方法名相同：

   • 在 Calculator 类中，我们定义了三个 add 方法，它们的名字都是 add。

2. 参数列表不同：

   • 第一个 add 方法接受两个 int 类型的参数。
   • 第二个 add 方法接受两个 double 类型的参数。
   • 第三个 add 方法接受三个 int 类型的参数。

3. 返回类型：

   • 第一个和第三个 add 方法返回 int 类型的结果。
   • 第二个 add 方法返回 double 类型的结果。

调用重载方法

在 main 方法中，我们创建了一个 Calculator 对象，并调用了不同的 add 方法。Java编译器会根据传入的参数类型和数量，自动选择合适的重载方法进行调用。

• calculator.add(5, 3)：调用接受两个 int 参数的 add 方法，返回 8。
• calculator.add(5.5, 3.3)：调用接受两个 double 参数的 add 方法，返回 8.8。
• calculator.add(5, 3, 2)：调用接受三个 int 参数的 add 方法，返回 10。

另一个示例：构造方法重载

构造方法也可以重载。下面是一个示例，展示了如何在一个类中定义多个构造方法：

public class Person {
    private String name;
    private int age;

    // 无参构造方法
    public Person() {
        this.name = "Unknown";
        this.age = 0;
    }

    // 带一个 String 参数的构造方法
    public Person(String name) {
        this.name = name;
        this.age = 0;
    }

    // 带两个参数的构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void display() {
        System.out.println("Name: " + name + ", Age: " + age);
    }

    public static void main(String[] args) {
        Person p1 = new Person();
        Person p2 = new Person("Alice");
        Person p3 = new Person("Bob", 25);

        p1.display(); // 输出: Name: Unknown, Age: 0
        p2.display(); // 输出: Name: Alice, Age: 0
        p3.display(); // 输出: Name: Bob, Age: 25
    }
}

详细解释

1. 无参构造方法：

   • Person()：初始化 name 为 "Unknown"，age 为 0。

2. 带一个参数的构造方法：

   • Person(String name)：初始化 name 为传入的参数值，age 为 0。

3. 带两个参数的构造方法：

   • Person(String name, int age)：初始化 name 和 age 为传入的参数值。

调用构造方法

在 main 方法中，我们创建了三个 Person 对象，分别使用不同的构造方法。每个对象的属性根据使用的构造方法进行初始化。

• new Person()：调用无参构造方法。
• new Person("Alice")：调用带一个 String 参数的构造方法。
• new Person("Bob", 25)：调用带两个参数的构造方法。