Best Practices für das Umschreiben von Funktionen: Setzen Sie das Potenzial der Vererbung frei und verbessern Sie die Wartbarkeit des Codes

Best Practices für das Umschreiben von Funktionen: Stellen Sie die Kapselung sicher: Schreiben Sie nur das Verhalten neu, das geändert werden muss. Verwenden Sie Überschreibungsanmerkungen: Geben Sie explizit überschreibende Methoden der übergeordneten Klasse an. Befolgen Sie das Liskov-Substitutionsprinzip: Abgeleitete Klassenobjekte können übergeordnete Klassenobjekte ersetzen, ohne das Programmverhalten zu ändern. Vermeiden Sie virtuelle Methoden: Überschreiben ist vorzuziehen und bietet eine stärkere Typprüfung.

Best Practices für das Umschreiben von Funktionen: Setzen Sie das Potenzial der Vererbung frei und verbessern Sie die Wartbarkeit des Codes

In der objektorientierten Programmierung ist Vererbung ein leistungsstarker Mechanismus, um die Wiederverwendung und Polymorphie von Code zu erreichen. Durch Funktionsüberschreibung kann das Verhalten der übergeordneten Klasse erweitert werden, um den spezifischen Anforderungen der abgeleiteten Klasse gerecht zu werden. Die Einhaltung bewährter Methoden ist entscheidend, um die Wirksamkeit von Funktionsüberschreibungen und die Wartbarkeit des Codes sicherzustellen.

1. Stellen Sie die Kapselung sicher

Beim Umschreiben einer Funktion sollte die Kapselung der übergeordneten Klassenimplementierung beibehalten werden. Dies bedeutet, dass nur das Verhalten überschrieben wird, das geändert werden muss, ohne die ursprüngliche Implementierung zu beschädigen. Beispiel:

class Animal:
    def make_sound(self):
        return "Generic animal sound"

class Dog(Animal):
    def make_sound(self):
        return "Woof!"

2. Verwenden Sie Überschreibungsanmerkungen

Verwenden Sie in der abgeleiteten Klasse, die die Funktion überschreibt, die Annotation @override, um deutlich anzugeben, dass die Methode der übergeordneten Klasse überschrieben wird. Dies hilft, Ihren Code zu dokumentieren und versehentliche Überschreibungen zu vermeiden. Beispiel: @override 注释明确表明正在重写父类方法。这有助于文档化代码，并避免意外覆盖。例如：

@override
class Dog(Animal):
    def make_sound(self):
        return "Woof!"

3. 遵循 Liskov 替换原则

函数重写应遵循 Liskov 替换原则，即子类对象必须能够替换其父类对象，并且程序行为不会改变。这确保了派生类的行为与预期一致。例如：

class Shape:
    def calculate_area(self):
       raise NotImplementedError()

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def calculate_area(self):
        return self.width * self.height

4. 避免虚方法

在大多数情况下，使用重写比虚方法更可取。重写提供更强的类型检查，并且允许子类在运行时确定父类的实现。例如：

class Animal:
    def make_sound(self):
        pass

class Dog(Animal):
    def make_sound(self):
        return "Woof!"

实战案例

以下是一个实战案例，展示了如何使用函数重写扩展父类的行为：

考虑一个 Employee 父类，其中包含一个 calculate_salary 方法。现在，我们需要创建一个 Manager 派生类，它具有自己的 calculate_bonus 方法。

class Employee:
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary

    def calculate_salary(self):
        return self.salary

class Manager(Employee):
    def __init__(self, name, salary, bonus):
        super().__init__(name, salary)
        self.bonus = bonus
    
    def calculate_salary(self):
        total_salary = super().calculate_salary() + self.bonus
        return total_salary

通过重写 calculate_salary 方法，Manager 类可以计算包含奖金在内的总工资，而无需破坏 Employeerrreee

Das obige ist der detaillierte Inhalt vonBest Practices für das Umschreiben von Funktionen: Setzen Sie das Potenzial der Vererbung frei und verbessern Sie die Wartbarkeit des Codes. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!