14、抽象类与接口：`abc`模块详解，`abstractmethod`的使用，设计稳定的基类契约。

说到面向对象编程，有个概念绕不开——抽象类与接口。很多初学者觉得这东西虚无缥缈，说白了，它就是一套「强制规则」。你想想看，团队协作时，最怕什么？最怕每个人对同一个类的理解不一样，实现方式五花八门。抽象类就是来解决这个问题的。

我个人习惯，在设计大型项目时，先把基类契约定死。就像盖楼先打地基，地基不稳，后面全白搭。今天我们就来聊聊 Python 里的 abc 模块，以及如何用它设计稳定的基类契约。

14.1 什么是抽象类？为什么需要它？

抽象类，你可以把它理解成一张「蓝图」。它定义了一组方法签名，但不提供具体实现。子类必须实现这些方法，否则无法实例化。

我在项目中遇到过这样一个场景：要开发一个日志系统，支持文件日志、数据库日志、网络日志。如果不用抽象类，每个人写的日志类可能方法名都不一样——有人用 log()，有人用 write()，还有人用 record()。调用方就懵了，到底该调哪个？

抽象类的作用，就是强制统一接口。你只要继承我的基类，就必须实现我规定的方法。这就是「契约」的含义。

14.2 `abc` 模块与 `abstractmethod` 的使用

Python 的 abc 模块提供了抽象类的支持。核心就是 ABC 类和 abstractmethod 装饰器。

来看一个最简单的例子：

from abc import ABC, abstractmethod

class Logger(ABC):
    @abstractmethod
    def log(self, message: str) -> None:
        pass

class FileLogger(Logger):
    def log(self, message: str) -> None:
        with open('app.log', 'a') as f:
            f.write(f"{message}\n")

class DatabaseLogger(Logger):
    def log(self, message: str) -> None:
        # 假设这里写入数据库
        print(f"DB: {message}")

# 下面这行会报错，因为抽象类不能实例化
# logger = Logger()

file_logger = FileLogger()
file_logger.log("这是一条日志")  # 正常

嗯，这里要注意：@abstractmethod 装饰的方法，子类必须实现。如果子类没实现，实例化时会抛出 TypeError。这个机制非常有用，它把错误提前到了「写代码时」而不是「运行时」。

14.3 抽象类 vs 接口：Python 里的特殊关系

很多语言（比如 Java）严格区分抽象类和接口。抽象类可以有实现，接口只能有声明。但 Python 没有专门的 interface 关键字。那怎么办？

实际上，Python 的抽象类可以同时扮演「抽象类」和「接口」两种角色。你可以用纯抽象方法模拟接口，也可以混入具体实现。

我曾经在重构一个支付系统时，就用了这种混合方式：

from abc import ABC, abstractmethod

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

    @abstractmethod
    def refund(self, transaction_id: str) -> bool:
        pass

    def get_payment_type(self) -> str:
        # 这是一个具体方法，子类可以直接用
        return self.__class__.__name__

class Alipay(Payment):
    def pay(self, amount: float) -> bool:
        print(f"支付宝支付 {amount} 元")
        return True

    def refund(self, transaction_id: str) -> bool:
        print(f"支付宝退款 {transaction_id}")
        return True

class WechatPay(Payment):
    def pay(self, amount: float) -> bool:
        print(f"微信支付 {amount} 元")
        return True

    def refund(self, transaction_id: str) -> bool:
        print(f"微信退款 {transaction_id}")
        return True

你看，Payment 既有抽象方法（强制子类实现），也有具体方法（提供公共逻辑）。这就是 Python 的灵活之处。

14.4 设计稳定的基类契约

设计基类契约，说白了就是「定规矩」。规矩定得好，团队开发效率翻倍；定得不好，后面全是坑。

我总结了几条经验：

1. 抽象方法要少而精。 只定义核心行为，不要什么都抽象。抽象方法越多，子类负担越重。
2. 提供默认实现。 如果某个方法大部分子类实现都一样，直接在基类里写好默认逻辑。子类想改再重写。
3. 用文档字符串说明契约。 每个抽象方法都要写清楚「输入是什么」「输出是什么」「有什么副作用」。
4. 考虑用属性代替方法。 如果某个行为更像「状态」而不是「动作」，用 @abstractproperty（Python 3.3+ 已废弃，改用 @property + @abstractmethod）。

来看一个更完整的例子：

from abc import ABC, abstractmethod

class DataSource(ABC):
    """数据源基类，所有数据源必须实现读取和写入"""
    
    @abstractmethod
    def read(self) -> str:
        """读取数据，返回字符串"""
        pass

    @abstractmethod
    def write(self, data: str) -> bool:
        """写入数据，成功返回 True"""
        pass

    @property
    @abstractmethod
    def name(self) -> str:
        """数据源名称，只读属性"""
        pass

    def exists(self) -> bool:
        """检查数据源是否存在，默认实现"""
        return False

class FileSource(DataSource):
    def __init__(self, path: str):
        self._path = path

    def read(self) -> str:
        with open(self._path, 'r') as f:
            return f.read()

    def write(self, data: str) -> bool:
        with open(self._path, 'w') as f:
            f.write(data)
        return True

    @property
    def name(self) -> str:
        return f"File: {self._path}"

    def exists(self) -> bool:
        import os
        return os.path.exists(self._path)

14.5 知识体系图

下面这张图展示了抽象类与接口的核心知识结构：

14.6 总结

抽象类和接口，是面向对象设计中「契约精神」的体现。用 abc 模块，你可以定义稳定的基类，强制子类遵循统一规范。这在大团队协作中尤其重要。

最后分享一个经验：不要过度设计。我见过有人把每个类都搞成抽象类，结果子类只有一两个，反而增加了复杂度。抽象类用在「多态扩展点」上，比如插件系统、策略模式、模板方法模式，效果最好。

记住，抽象类的本质是「约定大于配置」。约定写好了，代码自然就稳了。