Solidity语言学习——（六）

Solidity面向对象

面向对象：oo编程，正对过程而言。

特点：封装，继承，多态。

Solidity中的面向对象：

继承：在solidity中，继承就是合约与合约之间的一种特殊的传递关系。通过is关键字实现继承，子合约（派生合约）可以访问父合约中所有非private的状态变量与函数。继承支持参数的传递。solidity支持多重继承，但是多重继承中不能有同名的合约，如果一个合约继承了多个其他的合约，在区块链上只会创建一个合约，父合约中的代码都会进行拷贝形成继承（也就是把父合约代码拷贝到子合约中），如果一个合约继承了多个父合约，而这个父合约中有同名函数，默认继承最后一个函数。前的合约同名函数被覆盖了，如果需要调用指定父合约中的函数，可以通过合约名称进行显示指定。

抽象：抽象合约没有函数体，也可能包含一些正常得函数，但是只要有一个抽象函数，他就是抽象合约，不能通过编译，可以被继承，抽象类似于多态，子合约通过继承完成同名函数的不同实现。

// 5. 抽象
// 1). 抽象合约
contract AbstractContract {
    function someAbstractFunction(uint x); // 抽象函数
}

// 2). 子合约1
contract add is AbstractContract {
    uint sum;
    function someAbstractFunction(uint x) {
        sum = x + x;
    }

    function getSum() view public returns(uint) {
        return sum;
    }
}

// 3). 子合约2
contract square is AbstractContract{
    uint sq;

    function someAbstractFunction(uint x) {
        sq = x ** 2; // ** 表示求冥
    }

    function getSq() view public returns(uint) {
        return sq;
    }
}

 

库：关键字library

在solidity中，库也是一种合约，没有存储，不能存储以太币。没有payable函数，也没有fallbase函数，库可以直接部署，但不能直接访问其中的函数。通常用于公共功能，类似于golang中的package。

// 1). 用于运算的库
library Alg {
    // add
    function add(uint x, uint y) public returns (uint) {
        return x + y;
    }

    // add
    function sub(uint x, uint y) public returns (uint) {
        return x - y;
    }

    // add
    function mul(uint x, uint y) public returns (uint) {
        return x * y;
    }

    // add
    function div(uint x, uint y) public returns (uint) {
        return x / y;
    }

    function getAddress() public returns(address) {
        return this;
    }
}

// 2). 调用库的合约
contract Call {
    function getSum(uint x, uint y) public returns(uint) {
        return Alg.add(x, y);
    }

    function getAddr() public view returns(address) {
        return Alg.getAddress();
    }
}

Using for（附着库）

声明：Using  a for b;  将类型a中定义的所有函数都附着在任意类型b上面，类型b上面的实例可以调用a的所有方法

 

// 1). using array
// 实现一个数组的查找库，如果存在指定元素，返回该元素的索引，否则返回-1

library Search {
    function indexOf(uint[] storage self, uint value) returns(uint) {
        for (uint i = 0; i < self.length; i++) {
            if (self[i] == value) {
                return i;
            }
        }
        return uint(-1);
    }
}

// using a for b
contract Arr {
    using Search for uint[];
    uint[] data;

    // 追加元素
    function append(uint value) {
        data.push(value);
    }

    // 查找
    function contains(uint value) view public returns(bool) {
        // Search库中的函数会接收uint[]数组的实例，会把data作为第一个参数
        if (uint(-1) == data.indexOf(value)) {
            return false;
        }else {
            return true;
        }
    }
}

using for mapping

library Set {
    struct Data {
        mapping (uint => bool) flags;
    }
    // 插入
    function insert(Data storage self, uint value) returns(bool) {
        if(self.flags[value]) {
            return false;
        } else {
            self.flags[value] = true;
            return true;
        }
    }
    // 删除
    function remove(Data storage self, uint value) returns(bool) {
        if (!self.flags[value]) {
            return true;
        } else {
            self.flags[value] = false;
        }
    }
        

    // 包含

    function contains(Data storage self, uint value) returns(bool) {
        return self.flags[value];
    }
}

contract useSet {
    using Set for Set.Data; 
    Set.Data  data; // 结构体
    // 插入数据
    function Insert(uint value) public returns(bool){
        return data.insert(value);
    }

    // 查找
    function has(uint value) view public returns(bool){
        return data.contains(value);
    }
}

 

事件

事件是使用EVM的日志内置的工具，在真实的环境中，发送交易调用只能合约的过程，关键字：event

交易发送->打包->执行交易，再发送交易之后。不会马上返回执行结果，只会立刻返回一个交易哈希，事件可以继承，在合约内不能直接访问。

import

 导入其他源文件

import "filename",把指定的文件导入到当前全局范围内。

异常处理

 throw：如果发生异常，消耗发送的所有gas，没有异常信息，回滚所有状态。

require（bool condition）：自行判断，如果不满足条件也会产生异常，返回未使用的gas，一般来说尽可能的只用require，回滚已修改的状态。

assert（bool condition）：如果产生异常，返回剩余未使用的gas，回滚（已修改的状态）

revert（）：终止执行，回滚所有状态。

// 9 异常实例
contract ex{
    mapping(string=>uint) nameToBalance; 

    // 插入数据
    function insert(string name, uint balance) {
        nameToBalance[name] = balance;
    }
    // 查找
    function getBalance(string name) view returns(uint) {
        if (nameToBalance[name] == 0) {
            throw; // 抛出异常
        }

        if (bytes(name).length == 0) {
            throw;
        }
        return nameToBalance[name];
    }
}