# 这种写法每加一种支付方式就要修改代码
def process_payment(pay_type):
    if pay_type == "WECHAT":
        print("处理微信支付")
        # 微信支付逻辑...
    elif pay_type == "ALIPAY":
        print("处理支付宝支付")
        # 支付宝支付逻辑...
    else:
        raise ValueError("不支持的支付方式")
      
# 使用示例
process_payment("WECHAT")  # 处理微信支付

from abc import ABC, abstractmethod

# 策略接口
class PayStrategy(ABC):
    @abstractmethod
    def pay(self): pass
      
# 具体策略
class WechatPay(PayStrategy):
    def pay(self): print("微信支付")
      
class Alipay(PayStrategy):
    def pay(self): print("支付宝支付")
      
# 使用
def process_payment(strategy: PayStrategy):
    strategy.pay()
  
# 新增支付方式只需添加新类
class ApplePay(PayStrategy):
    def pay(self): print("Apple Pay")

from abc import ABC, abstractmethod

class AbstractUser(ABC):
    @abstractmethod
    def access(self): pass
      
class NormalUser(AbstractUser):
    def access(self): print("普通用户访问")
      
class AdminUser(AbstractUser):
    def access(self): 
        print("管理员访问")
        print("执行管理员特权操作")

class NotificationService:
    def send_email(self): ...
    def send_sms(self): ...
    def send_push(self): ...

class EmailNotification:
    def send_email(self): ...
                   
class SmsNotification:
    def send_sms(self): ...
                 
class PushNotification:
    def send_push(self): ...

class SmsNotification:
    def send(self, message):
        print(f"[短信] {message}")
      
class OrderService:
    def __init__(self):
        self.notifier = SmsNotification()  # 直接实例化具体类
    
    def create_order(self):
        print("创建订单业务逻辑...")
        self.notifier.send("订单创建成功")
      
# 使用
service = OrderService()
service.create_order()

from abc import ABC, abstractmethod

# 1. 定义抽象（高层模块不应依赖低层模块，二者都应依赖抽象）
class NotificationService(ABC):  # 抽象接口
    @abstractmethod
    def send(self, message: str) -> None:
        pass
      
# 2. 具体实现（低层模块依赖抽象）
class SmsNotification(NotificationService):
    def send(self, message):
        print(f"[短信] {message}")
      
class EmailNotification(NotificationService):
    def send(self, message):
        print(f"[邮件] {message}")
      
# 3. 业务类通过依赖注入使用抽象（高层模块依赖抽象）
class OrderService:
    def __init__(self, notifier: NotificationService):  # 依赖注入
        self.notifier = notifier
    
    def create_order(self):
        print("创建订单业务逻辑...")
        self.notifier.send("订单创建成功")
      
# 使用示例
if __name__ == "__main__":
    # 可以灵活切换通知方式
    sms_service = OrderService(SmsNotification())
    sms_service.create_order()  # 输出: [短信] 订单创建成功
    email_service = OrderService(EmailNotification())
    email_service.create_order()  # 输出: [邮件] 订单创建成功
    # 单元测试时可以轻松注入Mock
    class MockNotification(NotificationService):
        def send(self, message):
            print(f"[测试] {message}")
    test_service = OrderService(MockNotification())
    test_service.create_order()  # 输出: [测试] 订单创建成功

class UserService:
    def register(self, user):
        # 直接操作数据库细节
        conn = psycopg2.connect("dbname=test user=postgres")
        cursor = conn.cursor()
        cursor.execute(
            "INSERT INTO users (name, email) VALUES (%s, %s)",
            (user.name, user.email)
        )
        conn.commit()
        # 还有更多直接操作数据库的代码...

class UserRepository:
    def __init__(self):
        self.conn = psycopg2.connect("dbname=test user=postgres")
    
    def save(self, user):
        cursor = self.conn.cursor()
        cursor.execute(
            "INSERT INTO users (name, email) VALUES (%s, %s)",
            (user.name, user.email)
        )
        self.conn.commit()
      
class UserService:
    def __init__(self):
        self.repo = UserRepository()
    
    def register(self, user):
        # 只关注业务逻辑
        self.repo.save(user)
        # 可以在这里添加其他业务逻辑...