依赖倒置

依赖倒置原则是面向对象编程的一个重要原则之一，它指出高层模块不应该依赖于底层模块，它们应该都依赖于抽象的接口。而抽象的接口不应该依赖于具体实现，具体实现应该依赖于抽象的接口。

下面是一个简单的基于 Python 的依赖倒置示例：

python
from abc import ABC, abstractmethod


class PaymentService(ABC):
    @abstractmethod
    def process_payment(self, amount: float) -> bool:
        pass


class PayPalPaymentService(PaymentService):
    def process_payment(self, amount: float) -> bool:
        print(f"Processing payment of {amount} via PayPal")
        # 实际的支付逻辑代码


class StripePaymentService(PaymentService):
    def process_payment(self, amount: float) -> bool:
        print(f"Processing payment of {amount} via Stripe")
        # 实际的支付逻辑代码


class Order:
    def __init__(self, payment_service: PaymentService):
        self.payment_service = payment_service

    def checkout(self, total_amount: float):
        if self.payment_service.process_payment(total_amount):
            print("Payment processed successfully!")
        else:
            print("Payment failed.")


if __name__ == '__main__':
    paypal_payment_service = PayPalPaymentService()
    stripe_payment_service = StripePaymentService()

    order1 = Order(paypal_payment_service)
    order1.checkout(100.0)

    order2 = Order(stripe_payment_service)
    order2.checkout(200.0)
在这个示例中，我们首先定义了一个名为 PaymentService 的抽象基类，其中定义了一个名为 process_payment() 的抽象方法。然后，我们定义了两个具体的支付服务类：PayPalPaymentService 和 StripePaymentService，它们都实现了 PaymentService 接口。

接下来，我们定义了一个名为 Order 的类，它依赖于 PaymentService 接口，并在其构造函数中注入了一个 PaymentService 实例。在 Order 类的 checkout() 方法中，我们调用 PaymentService.process_payment() 方法来进行支付操作。

在主程序中，我们创建了两个不同的 PaymentService 实例：一个是 PayPalPaymentService，另一个是 StripePaymentService。然后，我们分别创建了两个 Order 实例，并将它们的构造函数参数设置为不同的 PaymentService 实例。最后，我们调用了每个 Order 实例的 checkout() 方法来执行订单结算，并使用不同的支付服务进行支付。