继承(Inheritance)

继承的本质：
继承的实现方案是代码拷贝，所以合约继承后，部署到网络时，将变成一个合约。代码将从父类拷贝到子类中。

继承的定义

继承使用is，一个合约可以继承多个合约，用逗号分开。
如果继承的合约之间也有父子关系，那么合约要按照先父到子的顺序排序。
比如：

contract X {}
contract A is X {}
contract C is X, A {} // 先X，再A

继承的可见性

子合约不能访问父合约的private私有成员
子合约可以访问父合约所有的非私有成员（包括internal的函数和状态变量）

父合约传参

继承的子合约，必须提供父合约构造方法需要的所有参数，有两种方式实现，如下：

   contract Base {
        uint x;
        function Base(uint _x) { x = _x; }
    }
    contract Derived is Base(7) { //方式一
        //方式二
        function Derived(uint _y) Base(_y * _y) {
        }
    }

继承中的重名

当继承多个合约时，这些父合约中不允许出现相同的函数名，事件名，修改器名，或互相重名。

pragma solidity ^0.4.0;

contract Base1{
  address owner;
  modifier ownd(){
    if(msg.sender == owner) _;
  }

  event dupEvent(address, bytes);

  function dupFunc(){
    dupEvent(msg.sender, msg.data);
  }
}

contract Base2{
  address owner;
  modifier ownd(){
    if(msg.sender == owner) _;
  }

  event dupEvent(address, bytes);

  function dupFunc(){
    dupEvent(msg.sender, msg.data);
  }
}
//失败，将会报错 Identifier already declared
//contract DuplicateNames is Base1, Base2{}
  contract DuplicateNames is Base1{}

还有一种比较隐蔽的情况，默认状态变量的getter函数导致的重名

重写

在子类中允许重写函数，但不允许重写返回参数签名，一起来看看下面的代码：

contract Base{
  function data() returns(uint){
    return 1;
  }
}

contract InheritOverride is Base{
  function data(uint){}
  function data() returns(uint){}
  //Override changes extended function signature
  //function data() returns(string){}
}

上面代码中的function data() returns(string){}将导致Override changes extended function signature报错，因为不能修改返回签名。

抽象(Abstract Contracts)

抽象函数是没有函数体的函数
抽象合约是包含了抽象函数的合约，比如

contract Feline {
    function utterance() returns (bytes32);
}

这样的合约不能通过编译，即使合约内也包含一些正常的函数。但它们可以做为基合约被继承。

接口

接口与抽象合约类似，与之不同的是，接口内没有任何函数是已实现的，同时还有如下限制：

• 不能继承其它合约，或接口。
• 不能定义构造器
• 不能定义变量
• 不能定义结构体
• 不能定义枚举类
  其中的一些限制可能在未来放开。

接口基本上限制为合约ABI定义可以表示的内容，ABI和接口定义之间的转换应该是可能的，不会有任何信息丢失。

接口用自己的关键词表示：

interface Token {
    function transfer(address recipient, uint amount);
}

问题

1.a继承b，c继承b，是不是一定要写 constract c is a, b {}
2.下面的案例Final继承的Base1和Base2有重复的kill函数，没有问题吗
3.下面的案例中，super.kill()和mortal.kill()有什么差别

pragma solidity ^0.4.0;

contract owned {
    function owned() public { owner = msg.sender; }
    address owner;
}

contract mortal is owned {
    function kill() public {
        if (msg.sender == owner) selfdestruct(owner);
    }
}

contract Base1 is mortal {
    function kill() public { /* do cleanup 1 */ super.kill(); }
}


contract Base2 is mortal {
    function kill() public { /* do cleanup 2 */ super.kill(); }
}

contract Final is Base1, Base2 {
}