面向对象设计 SOLID 原则和python例子

onlyfansnft.art

已于 2023-01-18 22:17:21 修改

阅读量490

点赞数 1

分类专栏： Python学习 Python思考文章标签： python 面向对象 Powered by 金山文档

于 2023-01-18 22:13:09 首次发布

本文链接：https://blog.csdn.net/Sbtgmz/article/details/128730947

版权

Python学习同时被 2 个专栏收录

47 篇文章 2 订阅

订阅专栏

Python思考

6 篇文章 0 订阅

订阅专栏

面向对象设计 SOLID 原则共有 5 个，它们分别是：

1、依赖倒置原则 (Dependency Inversion Principle, DIP) ：指的是高层模块 (high-level modules) 不应该依赖于低层模块 (low-level modules), 两者都应该依赖于抽象 (abstractions)。也就是说要以抽象为基础，而不是以实现为基础来进行编程

我个人的理解是，要先抽象出一个接口类，然后接口不实现具体的实现，但要定义输入的参数，起到让调用的人作为参考的作用。


# 一个例子：

class LowLevelModule:
    def low_level_method(self):
        pass

class HighLevelModule:
    def __init__(self):
        self.low_level_module = LowLevelModule()

    def high_level_method(self):
        self.low_level_module.low_level_method()

# 在上面的代码中，HighLevelModule 类依赖于 LowLevelModule 类。为了遵循 DIP，我们应该将这种依赖关系反转过来：

class LowLevelModule:
    def low_level_method(self):
        pass

class HighLevelModule:
    def __init__(self, low_level_module):
        self.low_level_module = low_level_module

    def high_level_method(self):
        self.low_level_module.low_level_method()

# 在这个例子中，HighLevelModule 类不再依赖于具体的实现类 LowLevelModule，而是依赖于抽象（接口）。

2、里氏替换原则 (Liskov Substitution Principle, LSP) ：指的是如果一个程序中使用的是基类 (base class) 的对象，那么在不改变程序正确性的前提下，这个程序中基类对象的地方都可以使用其子类 (subclass) 对象来替换

我个人的理解是，要能够像调用父类一样调用子类，例如父类有一个方法是怎么调用的，子类也要有这个方法，并且是一样的调用这个方法


# 以下是一个例子：

class Shape:
    def area(self):
        pass

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

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

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

def calculate_area(shape: Shape) -> float:
    return shape.area()

rectangle = Rectangle(2, 3)
print(calculate_area(rectangle))  # 6

square = Square(2)
print(calculate_area(square))  # 4
# 在上面的代码中，我们定义了一个 Shape 类和两个子类 Rectangle 和 Square。
# 这两个子类都可以替换成基类 Shape，并且都可以正常工作。

# 在函数 calculate_area 中，我们传入了一个 Shape 类型的参数，这个函数可以处理任何继承
# 自 Shape 的子类，而不需要考虑具体的子类是什么，这就是里氏替换原则的体现。

# 里氏替换原则的要求是，子类需要满足的条件是，不破坏父类的约束条件，并且满足自己的约束条件。

3、开放封闭原则 (Open-Closed Principle, OCP) ：指的是一个类或模块应该对扩展开放，对修改封闭。也就是说，当需要新增功能时，应该通过增加新的代码来实现，而不是修改现有的代码。

我个人的理解是：由于一个类可能会被多个地方都使用到，如果随便对这个类进行修改，那么可能很多引用这个类的地方都需要进行修改，这个工作量是很大的，而且还容易没有全部地方都进行修改，从而引发 BUG。因此可以选择对这个类进行继承，将新功能在继承的子类里进行实现。也可以写一个名字跟原来的接口的名字不同的新接口。个人感觉重新写一个新名字的接口的方法更简单，但是如果要增加的新接口很多的话，还是使用子类继承更好。


以下是一个例子：

class Shape:
    def area(self):
        pass

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

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

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius ** 2

class ShapeCalculator:
    def calculate_area(self, shape):
        return shape.area()
    
calculator = ShapeCalculator()
rectangle = Rectangle(2, 3)
print(calculator.calculate_area(rectangle)) # 6
circle = Circle(2)
print(calculator.calculate_area(circle)) # 12.56

# 在上面的代码中，我们定义了一个基类 Shape， 两个子类 Rectangle 和 Circle。
# 在类 ShapeCalculator 中，我们有一个函数 calculate_area，该函数可以处理任何继承
# 自 Shape 的子类，而不需要考虑具体的子类是什么，这样我们可以在不修改现有代码的情况
# 下新增新的图形类型，这就是开放封闭原则的体现。

# 这种设计方式可以保证现有代码不会因新增功能而改变，从而降低维护代码的成本。

4、接口隔离原则 (Interface Segregation Principle, ISP) ：指的是客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上。

我个人的理解是：假如一个接口类有很多的接口，但是实现这个接口类的具体实现类，其实有很多接口是使用不到的，因此如果要一一实现这些接口，既无法具体实现，也没有必要耗费大量的时间精力去实现这些接口，因此需要将接口类尽量分成多个接口类，每个接口类都比较精简，这样在实现的时候，就可以避免要去实现它不需要实现的接口。


# 以下是一个例子:

class Document:
    def __init__(self, content):
        self.content = content

    def save(self):
        pass

    def print(self):
        pass

    def fax(self):
        pass

class SimplePrinter:
    def print(self, document: Document):
        print(document.content)

class Fax:
    def fax(self, document: Document):
        print(f"Faxing the document: {document.content}")

# 在上面的代码中，我们定义了一个Document类，它包含三个方法：save,print,fax。
# 然而，并不是所有的客户端都需要使用这三个方法，比如 SimplePrinter只需要使用
#  print 方法，而不需要使用 save, fax 方法，这样就导致了客户端不必要的依赖。

# 为了遵循 ISP，我们应该将这些接口拆分为更小的接口，比如：

class PrintableDocument(ABC):
    @abstractmethod
    def print(self):
        pass

class SaveableDocument(ABC):
    @abstractmethod
    def save(self):
        pass

class FaxableDocument(ABC):
    @abstractmethod
    def fax(self):
        pass

class Document(PrintableDocument, SaveableDocument, FaxableDocument):
    def __init__(self, content):
        self.content = content

    def save(self):
        pass

    def print(self):
        print(self.content)

    def fax(self):
        pass

class SimplePrinter:
    def print(self, document: PrintableDocument):
        print(document.content)

class Fax:
    def fax(self, document: FaxableDocument):
        print(f"Faxing the document: {document.content}")
# 这样，我们就将 Document 类拆分成了三个更小的接口

5、单一职责原则：单一职责原则 (Single Responsibility Principle, SRP) ：指的是一个类应该只有一个引起它变化的原因。也就是说，一个类只应该有一个负责其中的逻辑。

我个人的理解是：如果一个类需要实现多个职责，那么可能会导致这个类的功能不够明确，在实现时会增加很多不该在这个类中实现的功能。


# 以下是一个例子:

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

    def increase_salary(self, percent):
        self.salary = self.salary + (self.salary * percent) / 100

    def save_employee(self):
        # save the employee to the database
        pass

    def send_email(self):
        # send email to the employee
        pass
# 在上面的代码中，类 Employee 负责三种职责：薪水计算、存储到数据库和发送电子邮件。

# 为了遵循 SRP，我们应该将这些职责拆分成不同的类，比如：

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

class SalaryCalculator:
    def increase_salary(self, employee: Employee, percent):
        employee.salary = employee.salary + (employee.salary * percent) / 100

class EmployeeDB:
    def save_employee(self, employee: Employee):
        # save the employee to the database
        pass

class EmailSender:
    def send_email(self, employee: Employee):
        # send email to the employee
        pass

# 这样每个类只负责一个单一的职责，使得类更加简单，容易维护，这就是单一职责原则的体现。

这几个原则之间有没有互相矛盾的地方？

这几个原则之间并不会互相矛盾，而是相互补充和协同工作。

依赖倒置原则 (Dependency Inversion Principle, DIP) 强调的是高层模块不应该依赖低层模块，

而是应该依赖抽象。这个原则可以和单一职责原则 (Single Responsibility Principle, SRP) 协同工作，

因为如果低层模块有多个职责，那么就会增加高层模块的依赖。

里氏替换原则 (Liskov Substitution Principle, LSP) 强调的是子类应该能够替换父类。这个原则可以和

开放封闭原则 (Open-Closed Principle, OCP) 协同工作，因为如果父类是可扩展的，那么子类就可以扩展

父类的行为，而不会破坏程序的正确性。

接口隔离原则 (Interface Segregation Principle, ISP) 强调的是客户端不应该依赖它不需要的接口。

这个原则可以和依赖倒置原则 (Dependency Inversion Principle, DIP) 协同工作，因为如果低层模块的

接口不是客户端需要的，那么就会增加高层模块的依赖。

总之，这些原则是相互补充和协同工作的，它们的目的都是为了让代码更加简单，易于维护和扩展。遵循这些