Solidity中的继承

类似于Java中的多态，也是子继承父，孙继承父再继承爷。重写部分方法。

关键字：

virtual   //父类 
override  //子类

对于父类合约中的函数，在函数性质定义完之后可以加上“virtual“的关键字，这样代表这个函数到子类合约中需要被重写

contract JCA{  //充当父合约
    function foo() public pure virtual returns (string memory){
        return "A";
    }
    //添加了“virtual”代表该函数可以被重写
    function bar() public pure virtual returns (string memory){
        return "A";
    }
    function baz() public pure  returns (string memory){
        return "A";
    }
    //没有写“virtual”的方法将会被继承的子合约中
}

对于没有写关键字的函数则会将完整的函数继承到子类合约中。

对于子类，如果只继承一个父类合约的话，需要在开头声明继承的那个父合约，不像Java中使用”extand“的关键字，在solidity中使用”is“如

contract JCB is JCA{  //充当子合约
    function foo() public pure override  returns(string memory){
        return "B";
    }
    //增加“override”表示覆盖所继承合约中的函数部分，使用后别忘了在子合约名后添加上
    //“is 父合约名”
    function bar() public pure override returns (string memory){
        return "B";
    }
}

在子类合约中只继承一个合约时需要重写父类合约中带有”virtual“的函数，名相同，区别在于将”virtual“换成

”override“。

如果子类想继承多个合约的话需要采用

contract Z is X, Y{ //合约Z继承合约X与合约Y，如果还有则用逗号将合约名隔开

的方式，而且原则是：继承的少的放前面。并且在合约里对那些需要重写的函数

 function foo() public pure override(X,Y)  returns(string memory){
        return "de";
    }    
    //如果继承多个合约不仅在合约名哪里需要声明，在函数的方法里也需要
    //用“override(X,Y)”声明，第一个要注意继承的顺序，往后的声明则不需要注意顺序
    function bar() public pure override(Y,X)   returns (string memory){
        return "de";
    }

如果继承的合约中其中一个也是继承了别的合约，例如合约Y继承了合约X，合约Z继承了合约X和合约Y时，对合约Y里面那些要重写的函数

contract Y is X{ //合约Y继承合约X
    function foo() public pure virtual override  returns(string memory){
        return "shui";
    }    
    function bar() public pure virtual override  returns (string memory){
        return "shui";
    }
     function y() public pure returns (string memory){
        return "Y";
    }
}

 当父类合约中有构造函数时：

contract X { 
    string public name;
    constructor(string memory _name){
        name = _name;
    }
}

contract Y { 
    string public text;
    constructor(string memory _text){
        text = _text;
    }
}

对于子类合约，如果知道父级合约的构造函数数据类型的话则

//当父级合约中有构造函数，继承时在父级合约的后面“(数据类型)”填写相应类型的数据
//这个数据类型是指在父级合约中的构造函数中所定义的数据类型  
contract Z is X("yun"), Y("xue"){ //合约Z继承合约X与合约Y  
　　}

当然如果不知道父级合约构造函数的数据类型的话就需要手动输入数据了即

contract V is X , Y{
    constructor(string memory _name ,string memory _text) X(_name) Y(_text){
        //通过自己输入，将数据传给父合约
    }
}

两种方法可以混用。继承顺序影响运行顺序。