继承

当我们的合约代码越来越长。 当代码过于冗长的时候，最好将代码和逻辑分拆到多个不同的合约中，以便于管理。

有个让 Solidity 的代码易于管理的功能，就是合约 inheritance (继承)：

当一个合约继承自多个合约时，只会在区块链上创建单个合约，并将所有父合约中的代码复制到创建的合约中。

Solidity的继承与Python非常相似，特别是多继承。

contract Doge {
  function catchphrase() public returns (string) {
    return "So Wow CryptoDoge";
  }
}
contract BabyDoge is Doge {
  function anotherCatchphrase() public returns (string) {
    return "Such Moon BabyDoge";
  }
}

由于 BabyDoge 是从 Doge 那里 inherits （继承)过来的。 这意味着当你编译和部署了 BabyDoge，它将可以访问 catchphrase() 和 anotherCatchphrase()和其他我们在 Doge 中定义的其他公共函数。

这可以用于逻辑继承（比如表达子类的时候，Cat 是一种 Animal）。 但也可以简单地将类似的逻辑组合到不同的合约中以组织代码。

父构造函数的参数
派生的合约需要为父构造函数提供所有的参数。有两种方式：

pragma solidity ^0.4.14;
contract Base {
    uint x;
    function Base(uint _x) public { x = _x; }
}
contract Derived is Base(7) {
    function Derived(uint _y) Base(_y * _y) public {
    }
}

• 第一种是直接在继承列表里实现is Base(7)
• 第二种是在派生的构造器的头部，修饰符被调用时实现Base(_y * _y)。

使用原则：

• 如果构造函数参数是一个常量，并且定义了合约的行为或描述了它的行为，第一种方式比较方便。
• 如果父构造函数参数依赖于派生合约的构造函数，则必须使用第二种方法。
• 如果在这个荒谬的例子中，这两个地方都被使用，修饰符样式的参数优先。

当我们多个合约为多个文件的时候我们该怎么继承？

当你有多个文件并且想把一个文件导入另一个文件时，可以使用 import 语句：

import "./someothercontract.sol";

contract newContract is SomeOtherContract {

}

这样当我们在合约（contract）目录下有一个名为 someothercontract.sol 的文件（ ./ 就是同一目录的意思），它就会被编译器导入。

多继承

import "./someothercontract.sol"
import "./othercontract.sol";
contract newContract is SomeOtherContract,othercontract {

}

多继承顺序：

在is指令中给出父类的顺序很重要。在下面的代码中，Solidity会报错：“Linearization of inheritance graph impossible”。

// 以下代码无法编译
pragma solidity ^0.4.14;
contract X {}
contract A is X {}
contract C is A, X {}
------------------------------------------------------
// 以下代码可以编译通过
pragma solidity ^0.4.14;
contract X {}
contract A is X {}
contract C is X, A {}

原因是C要求X来重写A（定义A，X这个顺序），但A本身的要求重写X，这是一个矛盾，不能解决。

storage 和 memory

在 Solidity 中，有两个地方可以存储变量 —— storage 或 memory

Storage 变量是指永久存储在区块链中的变量。 Memory 变量则是临时的，当外部函数对某合约调用完成时，内存型变量即被移除。 你可以把它想象成存储在你电脑的硬盘或是RAM中数据的关系。

大多数时候你都用不到这些关键字，默认情况下 Solidity 会自动处理它们。 状态变量（在函数之外声明的变量）默认为“存储”形式，并永久写入区块链；而在函数内部声明的变量是“内存”型的，它们函数调用结束后消失。

然而也有一些情况下，你需要手动声明存储类型，主要用于处理函数内的 结构体 和 数组 时：

contract SandwichFactory {
  struct Sandwich {
    string name;
    string status;
  }

  Sandwich[] sandwiches;

  function eatSandwich(uint _index) public {
    // Sandwich mySandwich = sandwiches[_index];

    // ^ 看上去很直接，不过 Solidity 将会给出警告
    // 告诉你应该明确在这里定义 `storage` 或者 `memory`。

    // 所以你应该明确定义 `storage`:
    Sandwich storage mySandwich = sandwiches[_index];
    // ...这样 `mySandwich` 是指向 `sandwiches[_index]`的指针
    // 在存储里，另外...
    mySandwich.status = "Eaten!";
    // ...这将永久把 `sandwiches[_index]` 变为区块链上的存储

    // 如果你只想要一个副本，可以使用`memory`:
    Sandwich memory anotherSandwich = sandwiches[_index + 1];
    // ...这样 `anotherSandwich` 就仅仅是一个内存里的副本了
    // 另外
    anotherSandwich.status = "Eaten!";
    // ...将仅仅修改临时变量，对 `sandwiches[_index + 1]` 没有任何影响
    // 不过你可以这样做:
    sandwiches[_index + 1] = anotherSandwich;
    // ...如果你想把副本的改动保存回区块链存储
  }
}