方法重写与方法重载

1. 方法重载与方法重写的定义

方法重写（Overriding）

方法重写（Overriding）是指在子类中重新定义与父类中相同的方法。此操作允许子类提供特定的实现，以替代父类的实现。方法重写是实现多态性（Polymorphism）的关键机制。

方法重载（Overloading）

方法重载是指在同一类中使用相同的方法名，但不同的参数列表（参数数量或参数类型）。方法重载允许一个类中多个方法的存在，具有相同的功能但不同的输入。

2. 方法重写与方法重载的实现规则

方法重写（Overriding）

实现方法重写时，需要遵循以下几条规则：

• 方法名和参数列表相同：子类中的重写方法必须与父类中的方法一致。

• 返回类型相同或兼容：返回类型可以与父类相同，或者是父类返回类型的子类。

• 访问修饰符：子类重写的方法的访问修饰符必须与父类的方法相同或更具可见性（如protected可以被重写为public）。

• 不能重写静态方法：静态方法不能被重写，实际调用根据引用类型决定。

• 不能重写final方法：如果父类的方法被标记为final，则不能在子类中重写。

方法重载（Overloading）

实现方法重载时，可以遵循以下规则：

• 方法名相同：重载的方法必须使用相同的方法名。

• 参数列表不同：参数数量或参数类型必须不同，以便区分不同的重载方法。

• 返回类型可以不同：重载的方法可以有不同的返回类型，但唯一的区分依然是参数列表。

3. 示例代码

方法重写示例

class Animal {
    void sound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("Dog barks");
    }
}

方法重载示例

class MathUtils {
    // 方法重载
    int add(int a, int b) {
        return a + b;
    }

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

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

在重载示例中，MathUtils类具有多个名为add的方法，这些方法具有不同的参数列表。

4. 方法重写与方法重载的对比

其他编程语言中的方法重写与方法重载

C++

在C++中，方法重写和方法重载的实现相对简单。

方法重载

在C++中，可以通过定义相同名称但具有不同参数的函数来实现方法重载。关键词没有专门的关键字。

#include <iostream>
using namespace std;

class MathUtils {
public:
    // 方法重载
    int add(int a, int b) {
        return a + b;
    }

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

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

int main() {
    MathUtils math;
    cout << math.add(5, 10) << endl;      // 输出: 15
    cout << math.add(5.5, 4.5) << endl;   // 输出: 10
    cout << math.add(1, 2, 3) << endl;     // 输出: 6
    return 0;
}

方法重写

在C++中，方法重写需要使用virtual关键字标记基类中的方法，以及override关键字来标记派生类中的重写。

#include <iostream>
using namespace std;

class Animal {
public:
    virtual void sound() { // 使用virtual实现方法重写
        cout << "Animal makes a sound" << endl;
    }
};

class Dog : public Animal {
public:
    void sound() override { // 使用override实现重写
        cout << "Dog barks" << endl;
    }
};

int main() {
    Animal* animal = new Dog();
    animal->sound(); // 输出: Dog barks
    delete animal;
    return 0;
}

Python

在Python中，方法重载并不是内置的，但可以通过默认参数实现。方法重写是通过定义相同名称的方法实现的。

方法重载

Python不使用专门的重载机制，可以使用默认参数实现类似效果。

class MathUtils:
    def add(self, a, b, c=0):  # 使用可选参数实现重载
        return a + b + c

math = MathUtils()
print(math.add(5, 10))       # 输出: 15
print(math.add(5, 10, 2))    # 输出: 17

方法重写

在Python中，方法重写只需定义相同名称的方法。

class Animal:
    def sound(self):
        print("Animal makes a sound")

class Dog(Animal):
    def sound(self):  # 重写父类方法
        print("Dog barks")

animal = Dog()
animal.sound()  # 输出: Dog barks

JavaScript

在JavaScript中，方法重载不被直接支持，但可以通过对象属性的方式实现。方法重写通过原型继承机制实现。

方法重载

可以通过实现一个函数并检查参数的类型，来模拟方法重载。

class MathUtils {
    add(a, b, c) {
        if (typeof c === 'undefined') {
            return a + b;
        } else {
            return a + b + c;
        }
    }
}

const math = new MathUtils();
console.log(math.add(5, 10));      // 输出: 15
console.log(math.add(5, 10, 2));   // 输出: 17

方法重写

JavaScript使用原型链来实现方法重写。

class Animal {
    sound() {
        console.log("Animal makes a sound");
    }
}

class Dog extends Animal {
    sound() { // 重写父类方法
        console.log("Dog barks");
    }
}

const animal = new Dog();
animal.sound();  // 输出: Dog barks

5.方法重写与重载的总结表格

表格 1: 方法重写对比

表格 2: 方法重载对比

6. 体现的编程思维

方法重写（Overriding）

1. 多态性

多态性是面向对象编程的一个核心概念。方法重写允许父类引用指向子类对象，这样在运行时可以调用子类的实现。例如，当我们创建一个Animal类型的引用，并让它指向一个Dog对象时，调用sound方法时实际上会执行Dog类中的sound实现，而不是Animal类中的实现。这种能力让开发者能够编写更加灵活和可扩展的代码，因为可以随时替换或扩展子类，而无需修改其他依赖于父类引用的代码。

2. 代码重用

方法重写促进了代码重用。通过继承，子类可以直接获取父类的属性和方法，在这基础上添加或修改具体的实现。这种方式减少了代码重复，在多个子类中共享通用逻辑，同时也确保了在父类修改时，所有子类的实现都能保持一致。例如，如果父类有一个通用的move方法，所有子类都可以重用这个方法，而不需要在每个类中重新实现。

3. 抽象化

抽象化是OOP的基本原则之一，通过方法重写，父类可以定义一个接口或抽象方法，让子类实现具体的行为。此时，父类提供统一的调用方式，而子类则负责具体的实现。这种机制使得代码更加灵活，增加了系统的可扩展性。例如，可以定义一个Shape类，其中有一个draw方法，所有形状的子类如Circle、Square都可以定义自己的draw实现，从而使得Shape类的使用者无须了解具体的实现细节，只需关注接口的使用。

4. 易于理解和维护

方法重写的结构通常比方法的不同实现更加清晰，通过定义父类的抽象或接口，子类的责任和行为可以非常明确。清晰的层次结构使得代码的可读性增强，维护变得更为简单。一旦发现bug或需要添加新功能，只需在子类中修改或扩展相应的方法。这种结构化设计降低了系统的复杂性，使得程序的逻辑结构更加清晰，有助于团体协作与项目的长远发展。

方法重载（Overloading）

方法重载强调的是同一方法名的多样性，通过不同的参数列表，使得一个方法可以处理不同类型或数量的输入。这种设计思维体现在以下几个方面：

1. 可读性与表达性

方法重载提高了代码的可读性和表达性。当多个相关操作使用相同的方法名时，阅读者可以快速理解这些方法之间的关系。例如，在数学计算中，add方法可以用于处理不同类型（整型、浮点型）的加法操作，避免了使用不同的名字来描述相似功能的方法。

2. 便捷性

重载可以使得代码更加便捷，程序员可以使用相同的功能调用，而不需要记住多个方法名。这在大多数情况下让代码更加紧凑，同时也易于在调用时传递参数，这些参数可能具有不同的数据类型或不同的数量。

3. 灵活性

方法重载为程序提供了灵活性，允许同一个功能以多种方式实现。在大型项目中，开发者可以根据不同的业务需求，提供多种操作接口。例如，考虑一个图形编辑器，用户可能需要绘制不同形状的方法，重载draw方法来处理不同的参数（如形状对象或具体坐标），能够灵活满足用户的需求。

4. 维护和扩展

使用方法重载可以使得程序在维护和扩展方面具有更多的选择。例如，假设需要实现一个新的add方法来处理复杂的数值对象。通过重载，而非替换原有方法，开发者可以轻松添加新功能，保持旧功能不变，从而不影响现有的代码逻辑和运行性能。