Solidity 中的继承机制是如何工作的？抽象合约和接口有什么区别？

Solidity 的继承机制是怎样的？

Solidity 使用 is 关键字实现单继承和多重继承。子合约可以继承父合约的状态变量和函数，并通过 virtual/override 关键字实现函数重写。多重继承时，Solidity 采用 C3 线性化算法确定调用顺序——继承列表中越靠右的基类优先级越高，super 会沿着线性化顺序向上调用。

solidity
contract Animal {
    function speak() public pure virtual returns (string memory) {
        return "Some sound";
    }
}

contract Dog is Animal {
    function speak() public pure override returns (string memory) {
        return "Woof!";
    }
}

// 多重继承：B 在 C 前面，但 super 从最右侧基类开始调用
contract D is B, C {
    function foo() public pure override(B, C) returns (string memory) {
        return super.foo(); // 调用 C.foo()
    }
}

构造函数的继承需要在子合约中显式调用。可以在继承列表中直接传参，也可以在子合约构造函数中动态传参。

抽象合约和接口有什么区别？

核心区别：抽象合约可以有部分实现（状态变量、构造函数、已实现的函数），接口则完全不能有任何实现，只能声明函数签名。

特性	抽象合约	接口
函数实现	可以有部分实现	不能有任何实现
状态变量	可以有	不能有
构造函数	可以有	不能有
函数可见性	任意	只能是 external
修饰符 modifier	可以有	不能有
继承	可继承合约和接口	只能继承接口

solidity
// 抽象合约：可以包含已实现的函数和状态变量
abstract contract Ownable {
    address public owner;
    constructor() { owner = msg.sender; }
    modifier onlyOwner() {
        require(msg.sender == owner, "Not owner");
        _;
    }
    function transferOwnership(address newOwner) public virtual onlyOwner {
        owner = newOwner;
    }
}

// 接口：只能声明函数签名，用于定义标准
interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 amount) external returns (bool);
    event Transfer(address indexed from, address indexed to, uint256 value);
}

什么时候用抽象合约，什么时候用接口？

用接口：定义合约间通信标准（如 ERC20、ERC721），让不同合约实现相同的外部接口以保证互操作性。接口的本质是 ABI 的代码表示。

用抽象合约：需要在基类中提供默认实现或共享状态时使用。比如 OpenZeppelin 的 Ownable、Pausable 都是抽象合约，它们提供了可复用的逻辑和状态变量，子合约继承后直接可用。

solidity
// 典型组合：抽象合约提供基础功能，接口定义外部标准
abstract contract Pausable is Ownable {
    bool public paused;
    modifier whenNotPaused() {
        require(!paused, "Paused");
        _;
    }
    function pause() public onlyOwner { paused = true; }
}

contract MyToken is ERC20, Ownable, Pausable {
    function transfer(address to, uint256 amount)
        public
        override(ERC20, IERC20)
        whenNotPaused
        returns (bool)
    {
        return super.transfer(to, amount);
    }
}

多重继承的 C3 线性化如何工作？

C3 线性化的核心规则：从继承列表最右侧的基类开始，逐步向左合并。super 调用不是跳到"父类"，而是跳到线性化序列中的下一个合约。

solidity
contract A {
    function foo() public pure virtual returns (string memory) { return "A"; }
}
contract B is A {
    function foo() public pure virtual override returns (string memory) { return "B"; }
}
contract C is A {
    function foo() public pure virtual override returns (string memory) { return "C"; }
}

// D is B, C → 线性化顺序: D → C → B → A
// super.foo() 在 D 中调用 C.foo()
contract D is B, C {
    function foo() public pure override(B, C) returns (string memory) {
        return super.foo(); // 返回 "C"
    }
}

面试追问：如果 D is C, B（调换顺序），super.foo() 会调用 B.foo() 而不是 C.foo()。继承顺序直接影响线性化结果，这是 Solidity 多重继承中最容易踩的坑。

函数重写的注意事项

• 父合约函数必须标记 virtual 才能被子合约重写
• 子合约重写时必须标记 override
• 多重继承中重写多个基类的同名函数，需要 override(B, C) 显式列出
• 父合约没有 virtual 的函数不可重写
• 访问修饰符不能降低可见性（public 不可降为 external）

继承的常见实践

1. 基础合约在前：继承列表中，更基础的合约放前面（如 is Ownable, Pausable, ERC20），虽然不影响线性化，但可读性更好
2. 优先使用 OpenZeppelin：Ownable、Pausable、ReentrancyGuard 等经过审计的抽象合约，不要自己造轮子
3. 接口定义标准，抽象合约共享逻辑：两者配合使用才是正解，不要二选一
4. 避免过深的继承层级：3 层以上的继承链会让代码难以追踪，优先用组合替代