一起学智能合约之七接口和抽象类

一起学智能合约之七接口和抽象类

继承说一下,不能有多个构造函数,结构体

• 接口

接口其实和其它语言的没有什么区别，只是略微增加了一些限制：

1、不能继承其它合约，或接口。

2、不能定义构造器

3、不能定义变量

4、不能定义结构体

5、不能定义枚举类

接口的关键字是interface:

interface Token {

    function transfer(address recipient, uint amount);

}

 

• 抽象类

抽象类有点类似于c里面的函数声明，在合约中没有函数体，那么这个类就是一个抽象类或者说抽象合约。

这样的合约直接编译会报错，因为没有函数体。正如c++一样，它的作用只是用来继承，它可以和接口一样做为抽象的接口来使用，也可以当做一个具体的类来被继承。

pragma solidity ^0.4.0;

 

contract Feline {

    function utterance() returns (bytes32);//没有函数体

}

但是它可以被继承：

contract Cat is Feline {

    function utterance() returns (bytes32) { return "miaow"; }

}

• 类

这里首先要说明的是，Solidity中没有所谓的多构造函数。只有一个（多个会编译错误）。

pragma solidity ^0.4.22;

 

contract Example{

   

     constructor() public{

       

    }

}

从0.4.22开始就不再使用普通的函数+合约名字来声明构造函数了，必须用constructor关键字。

另外，有构造函数就会有析构函数：

    function kill() {

       if (owner == msg.sender) { // 检查谁在调用

          selfdestruct(owner); // 销毁合约

       }

}

套路还是挺多的。需要注意，虽然这个简单，但是这玩意儿和钱打交道，一个不小心，就爽歪歪了。

• 继承

Solidity通过复制包括多态的代码来支持多重继承。

所有函数调用是虚拟(virtual)的，这意味着最远的派生方式会被调用，除非明确指定了合约。

当一个合约从多个其它合约那里继承，在区块链上仅会创建一个合约，在父合约里的代码会复制来形成继承合约。

基本的继承体系与python有些类似，特别是在处理多继承上面。

从上面的描述来看，硬生生的创造一门语言是多么难，所以不得不从别的语言中汲取精华，然后再增加自己的特点。

还是来看一下官网的例子：

pragma solidity ^0.4.0;

 

contract owned {

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

    address owner;

}

 

 

// Use "is" to derive from another contract. Derived

// contracts can access all non-private members including

// internal functions and state variables. These cannot be

// accessed externally via `this`, though.

contract mortal is owned {

    function kill() {

        if (msg.sender == owner) selfdestruct(owner);

    }

}

 

 

// These abstract contracts are only provided to make the

// interface known to the compiler. Note the function

// without body. If a contract does not implement all

// functions it can only be used as an interface.

contract Config {

    function lookup(uint id) returns (address adr);

}

 

 

contract NameReg {

    function register(bytes32 name);

    function unregister();

 }

 

 

// Multiple inheritance is possible. Note that "owned" is

// also a base class of "mortal", yet there is only a single

// instance of "owned" (as for virtual inheritance in C++).

contract named is owned, mortal {

    function named(bytes32 name) {

        Config config = Config(0xd5f9d8d94886e70b06e474c3fb14fd43e2f23970);

        NameReg(config.lookup(1)).register(name);

    }

 

    // Functions can be overridden by another function with the same name and

    // the same number/types of inputs.  If the overriding function has different

    // types of output parameters, that causes an error.

    // Both local and message-based function calls take these overrides

    // into account.

    function kill() {

        if (msg.sender == owner) {

            Config config = Config(0xd5f9d8d94886e70b06e474c3fb14fd43e2f23970);

            NameReg(config.lookup(1)).unregister();

            // It is still possible to call a specific

            // overridden function.

            mortal.kill();

        }

    }

}

 

// If a constructor takes an argument, it needs to be

// provided in the header (or modifier-invocation-style at

// the constructor of the derived contract (see below)).

contract PriceFeed is owned, mortal, named("GoldFeed") {

   function updateInfo(uint newInfo) {

      if (msg.sender == owner) info = newInfo;

   }

 

   function get() constant returns(uint r) { return info; }

 

   uint info;

}

调用kill时分了区分父子类的不同，可以使用super，这和JAVA啥的语言又很相似了。

pragma solidity ^0.4.0;

 

contract mortal is owned {

    function kill() {

        if (msg.sender == owner) selfdestruct(owner);

    }

}

 

contract Base1 is mortal {

    function kill() { /* do cleanup 1 */ super.kill(); }

}

 

contract Base2 is mortal {

    function kill() { /* do cleanup 2 */ super.kill(); }

}

 

contract Final is Base2, Base1 {

}

另外还得说一下，继承中构造函数的初始化问题：

pragma solidity ^0.4.0;

 

contract Base {

    uint x;

    function Base(uint _x) { x = _x; }

}

 

contract Derived is Base(7) {

    function Derived(uint _y) Base(_y * _y) {

    }

}

直接在继承列表中使用is Base(7)，或像修改器(modifier)使用方式一样，做为派生构造器定义头的一部分Base(_y * _y)。第一种方式对于构造器是常量的情况比较方便，可以大概说明合约的行为。第二种方式适用于构造的参数值由派生合约的指定的情况。在上述两种都用的情况下，第二种方式优先(一般情况只用其中一种方式就好了)。

多继承一般来说是不推荐的，不知道为啥Solidity要淌这混水。这里就不详细说这个了，如果有感兴趣的，直接去官网看吧。

如果在继承中有相同名字的不同类型的成员，编译是无法通过的。不过万事都有例外，状态变量的getter可以覆盖一个public的函数。

 

• 结构体

struct可以用于映射和数组中作为元素。其本身也可以包含映射和数组等类型。但是，不能把结构体做为结构体的成员。还是虚拟机惹得祸啊。

struct是一个比较大的值，当把一个struct赋值给一个局部变量（默认是storage类型）时，实际是拷贝引用 ，这就意味着，修改局部变量会引起struct的改变。

    struct Funder{

        address addr;

        uint amount;

    }

   

    struct Campaign{

        address beneficiary;

        uint goal;

        uint amount;

        uint funderNum;

        mapping(uint => Funder) funders;

}

结构体的使用其实就是为了简化数据的操作，没什么特殊的原因，而在Solidity上，struct不能像其它语言那样发挥出强大的功能。

• 总结

Solidity是一门语言，也有所谓的各种语言具有的一般能力，但是，它仍然是非常弱小的，指望着用它完成类似Java等语言的强大功能，就洗洗睡吧。