【Solidity】继承

继承

Solidity 中使用 is 关键字实现继承：

1. contract Father {
2.     function getNumber() public pure returns (uint) {
3.         return 10;
4.     }
6.     function getNumber2() public pure virtual returns (uint) {
7.         return 20;
8.     }
9. }
11. contract Son is Father {}

复制代码

现在 Son 就可以调用 Father 的 getNumber、getNumber2 方法啦



函数重写

对于父合约中用 virtual 修饰的方法，可以在子合约中改用 override 修饰 并重写方法的内容：

1. contract Father {
2.     function getNumber() public pure returns (uint) {
3.         return 10;
4.     }
6.     function getNumber2() public pure virtual returns (uint) {
7.         return 20;
8.     }
9. }
11. contract Son is Father {
12.     function getNumber2() public pure override returns (uint) {
13.         return 40;
14.     }
15. }

复制代码

多级继承

1. contract Father {
2.     function getNumber() public pure returns (uint) {
3.         return 10;
4.     }
6.     function getNumber2() public pure virtual returns (uint) {
7.         return 20;
8.     }
10.     function getNumber3() public pure virtual returns (uint) {
11.         return 30;
12.     }
13. }
15. contract Son is Father {
16.     function getNumber2() public pure override returns (uint) {
17.         return 40;
18.     }
20.     // 用 virtual 和 override 同时修饰方法
21.     function getNumber3() public pure virtual override returns (uint) {
22.         return 50;
23.     }
24. }
26. contract GrandSon is Son {
27.     function getNumber3() public pure override returns (uint) {
28.         return 60;
29.     }
30. }

复制代码

多重继承

在 Solidity 中，继承次序通过 C3 线性化算法确定。这个算法确保继承关系是一个有向无环图（DAG），并逼迫一个特定的继承次序。
demo1：

1.    X
2. / |
3. Y  |
4. \ |
5.    Z

复制代码

根据 C3 线性化算法，继承次序是从最底层的合约开始，逐层向上合并继承路径。详细步调如下：

• 从最底层合约 Z 开始：
  
  
  
  • Z 继承自 Y 和 X。
    
  • 继承次序：[Z, Y, X]。
    
  
  
• 合并继承路径：
  
  
  
  • Y 继承自 X。
    
  • 继承次序：[Y, X]。
    
  
  
• 最终继承次序：
  
  
  
  • 合并 Z 的继承次序 [Z, Y, X] 和 Y 的继承次序 [Y, X]。
    
  • 确保每个合约只出现一次，而且遵循继承关系。
    
  • 最终继承次序为：[Z, Y, X]。
    
  
  

1. contract X {
2.     function foo() public virtual returns (string memory) {
3.         return "X";
4.     }
5. }
7. contract Y is X {
8.     function foo() public virtual override returns (string memory) {
9.         return "Y";
10.     }
11. }
13. // 根据继承顺序, 先 X 后 Y;  若遇平级, 则顺序随意
14. contract Z is X, Y {
15.     // override 里面的顺序无所谓
16.     function foo() public pure override(Y, X) returns (string memory) {
17.         return "Z";
18.     }
19. }

复制代码

demo2：

1.   X
2. / \
3. Y   A
4. |   |
5. |   B
6. \ /
7.   Z

复制代码

根据 C3 线性化算法，继承次序是从最底层的合约开始，逐层向上合并继承路径。详细步调如下：

• 从最底层合约 Z 开始：
  
  
  
  • Z 继承自 Y 和 B。
    
  • 继承次序：[Z, Y, B]。
    
  
  
• 合并继承路径：
  
  
  
  • Y 继承自 X。
    
  • B 继承自 A，A 继承自 X。
    
  • 继承次序：[Y, X] 和 [B, A, X]。
    
  
  
• 最终继承次序：
  
  
  
  • 合并 Z 的继承次序 [Z, Y, B] 和 Y 的继承次序 [Y, X] 以及 B 的继承次序 [B, A, X]。
    
  • 确保每个合约只出现一次，而且遵循继承关系。
    
  • 最终继承次序为：[Z, Y, B, A, X]。
    
  
  

1. contract X {
2.     function foo() public virtual returns (string memory) {
3.         return "X";
4.     }
5. }
7. contract Y is X {
8.     function foo() public virtual override returns (string memory) {
9.         return "Y";
10.     }
11. }
13. contract A is X {
14.     function foo() public virtual override returns (string memory) {
15.         return "A";
16.     }
17. }
19. contract B is A {
20.     function foo() public virtual override returns (string memory) {
21.         return "B";
22.     }
23. }
25. contract Z is Y, B {
26.     function foo() public pure override(Y, B) returns (string memory) {
27.         return "Z";
28.     }
29. }

复制代码

调用父合约的构造函数

1. contract A {
2.     string public name;
4.     constructor(string memory _name) {
5.         name = _name;
6.     }
7. }
9. contract B {
10.     uint public number;
12.     constructor(uint _number) {
13.         number = _number;
14.     }
15. }
17. // demo 1 - 在构造函数后面调用基类构造函数
18. contract C is A, B {
19.     constructor(string memory _name, uint _number) A(_name) B(_number) {}
20. }
22. // demo 2 - 在合约定义时调用基类构造函数
23. contract D is A("Hello"), B(42) {}
25. // demo 3 - 混合使用 demo 1 和 2 的方法
26. contract E is A("Hello"), B {
27.     constructor(uint _number) B(_number) {}
28. }

复制代码

构造函数的调用次序：先继承的父合约 → 后继承的父合约 → 当前合约
以是，demo 1 是 A → B → C、 demo 2 是 A → B → D、 demo 3 是 A → B → E



调用父合约的方法

1. contract A {
2.     event Log(string message);
4.     function func() public virtual {
5.         emit Log("A.func");
6.     }
7. }
9. contract B is A {
10.     function func() public virtual override {
11.         emit Log("B.func");
12.         // 方法 1 - 通过 super 调用
13.         super.func(); // A
14.     }
15. }
17. contract C is A {
18.     function func() public virtual override {
19.         emit Log("C.func");
20.         // 方法 2 - 通过合约调用
21.         A.func(); // A
22.     }
23. }
25. contract D is B, C {
26.         // 方法 1 和方法 2 的区别
28.     function func() public override(B, C) {
29.         C.func(); // C - A
30.         B.func(); // B - A
31.         A.func(); // A
32.     }
34.     function funcD() public {
35.         super.func(); // C - B - A
36.     }
37. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。