基于以太坊的智能合约开发教程Solidity 继承与权限

pragma solidity ^0.4.0;

contract inheritTest{
    
    
    // pure 不会读取全局变量，更不会修改全局变量，一个固定的输入就会有一个固定的输出，不消耗gas
    
    // constant  在函数当中，和view相同，在全局变量当中，只用于bytes1-bytes32,uint,int,string,代表数据不能被修改
    
    // view 只读取全局变量的值，不修改它，不消耗gas


    // 如果不加任何的修饰符，是可以被继承的
    
    uint money = 10000;
    
    function jump()pure internal returns(string){
        return "jumping";
    }
    function sing()pure private  returns(string) {
        // private修饰的函数不能被继承
        return "I like Singing";
    }
}


contract testOne is inheritTest{
    
    
    // 子合约继承父合约，可以使用父合约中的money和jump方法
    
    uint money = 180;
    
    
    // 加上internal仍然可以被继承
    
    string  internal wallet = "qipilang";
    
    // private修饰的属性不能被继承   external不能修饰变量
    uint private height =180;
    
    function dance()pure internal returns(string){
    // internal修饰的函数只能在合约内部或者继承的合约内部调用，但是不能在合约外部调用
    // 带有internal的函数不会显示在合约当中，但可以在合约内部其他的函数当中去调用
        return "I like dancing";
    }
    
    function test0()pure external returns(uint){
        return 6666;
    }   
    
    function test1()public pure  returns(string){
         return jump();
    } 
    
    function test2()public view returns(string){
        return test1();
    }
    function example1()public view returns(uint){
        // return test0();   external修饰的函数只能在外部调用，通过this.代表合约的地址，通过间接的方法去调用
        return this.test0();
    }
}


contract testTwo is testOne{
    
    //  可连续继承
    
    function test3()public view returns(uint){
    // 如果一个子合约继承的父合约当中有一个与上一级父合约相同的变量，则子合约继承的是最近父合约当中的变量
        return money;
    }
    function test4()public view  returns(string,string){
        return (dance(),wallet);
    }
    function example2()public returns(uint){
    // external修饰的函数在继承的函数不能在内部调用，通过this.代表父合约的地址，通过间接的方法去调用
        return this.test0();
    }
    function dance()pure internal returns(string){
    // internal修饰的函数只能在合约内部或者继承的合约内部调用，但是不能在合约外部调用
    // 带有internal的函数不会显示在合约当中，但可以在合约内部其他的函数当中去调用
    // 继承的函数可以进行重载
        return "I likes dancing";
    }

}

contract externalTest{
   
    testOne t = new testOne();
    
    function test()public returns(uint){
        // 通过地址调用相当于外部调用
        return t.test0();
    }
}