多重继承

使用继承可以方便地实现代码重用，从而减少重复代码的数量并提高代码的可维护性。

Solidity 支持单一继承和多重继承，可以通过继承合约来扩展功能和属性。

示例

下面是一个简单的 Solidity合约继承的例子：

pragma solidity ^0.5.0;

contract Ownable {  // 父合约
    address public owner;

    constructor() public {
        owner = msg.sender;
    }

    modifier onlyOwner() {
        require(msg.sender == owner, "Only the owner can execute this function");
        _;
    }
}

contract Pausable {  // 父合约
    bool public paused;

    modifier whenNotPaused() {
        require(!paused, "This function can't be called while the contract is paused");
        _;
    }

    modifier whenPaused() {
        require(paused, "This function can only be called while the contract is paused");
        _;
    }

    function pause() public onlyOwner {
        paused = true;
    }

    function unpause() public onlyOwner {
        paused = false;
    }
}

contract MyContract is Ownable, Pausable {  // 子合约
    uint256 public value;

    function setValue(uint256 _value) public whenNotPaused {
        value = _value;
    }
}

在这个例子中，我们定义了两个父合约，Ownable 和 Pausable ，一个子合约MyContract。

Ownable 合约包含有关合约的拥有者的信息，并使用修饰符 onlyOwner 确保只有拥有者才能执行特定函数。

Pausable 合约提供了暂停和恢复合约的功能。

子合约 MyContract 继承了这两个父合约，并使用修饰符whenNotPaused来确保只有在合约未暂停的情况下才能调用setValue功能。

这样的设计可以减少代码重复，并且根据需求添加或修改合约的功能。

多重继承示例

pragma solidity ^0.5.0;

contract A {
    uint public numA;

    function setNumA(uint _num) public {
        numA = _num;
    }
}

contract B {
    uint public numB;

    function setNumB(uint _num) public {
        numB = _num;
    }
}

contract C is A, B {
    uint public numC;

    function setNumC(uint _num) public {
        numC = _num;
    }
}

在这个例子中，我们定义了三个合约，其中 C合约继承了 A 和 B 合约。

A 和 B 合约都有一个 setNum 函数，分别设置了 numA 和 numB 的值。在 C 合约中，我们还添加了一个setNumC 函数，用来设置 numC 的值。

这样，合约 C 可以使用 A 和 B 合约的 setNum 函数，并添加自己的函数。这样，我们可以减少重复代码并提高代码可重用性。