Solidez – Herencia

La herencia es una de las características más importantes del lenguaje de programación orientado a objetos. Es una forma de ampliar la funcionalidad de un programa, se utiliza para separar el código, reduce la dependencia y aumenta la reutilización del código existente. Solidity admite la herencia entre contratos inteligentes, donde se pueden heredar múltiples contratos en un solo contrato. El contrato del que otros contratos heredan características se conoce como contrato base, mientras que el contrato que hereda las características se denomina contrato derivado. Simplemente, se les conoce como contratos padre-hijo. El alcance de la herencia en Solidity se limita únicamente a los modificadores públicos e internos. Algunos de los aspectos más destacados de Solidity son: 

• Un contrato derivado puede acceder a todos los miembros no privados, incluidas las variables de estado y los métodos internos. Pero usar esto no está permitido.
• Se permite la anulación de funciones siempre que la firma de la función siga siendo la misma. En caso de diferencia de parámetros de salida, la compilación fallará.
• Podemos llamar a la función de un súper contrato usando una palabra clave súper o usando un nombre de súper contrato.
• En el caso de herencias múltiples, las llamadas a funciones que usan super dan preferencia a la mayoría de los contratos derivados.

La solidez proporciona diferentes tipos de herencia.

1. Herencia única

En la herencia de un solo nivel o de un solo nivel, las funciones y variables de un contrato base se heredan a un solo contrato derivado.

Ejemplo: En el siguiente ejemplo, el padre del contrato es heredado por el hijo del contrato, para demostrar la herencia única.

// Solidity program to
// demonstrate
// Single Inheritance
pragma solidity >=0.4.22 <0.6.0; 
 
// Defining contract 
contract parent{ 
 
    // Declaring internal
    // state variable 
    uint internal sum; 
       
    // Defining external function
    // to set value of internal
    // state variable sum
    function setValue() external { 
        uint a = 10;
        uint b = 20;
        sum = a + b;
    } 
} 
 
// Defining child contract 
contract child is parent{ 
      
    // Defining external function
    // to return value of
    // internal state variable sum
    function getValue(
    ) external view returns(uint) { 
        return sum; 
    } 
} 
   
// Defining calling contract
contract caller {
 
    // Creating child contract object
    child cc = new child();  
     
    // Defining function to call
    // setValue and getValue functions
    function testInheritance(
    ) public returns (uint) { 
        cc.setValue(); 
        return cc.getValue(); 
    } 
}

Producción : 

2. Herencia multinivel

Es muy similar a la herencia única, pero la diferencia es que tiene niveles de relación entre el padre y el hijo. El contrato hijo derivado de un padre también actúa como padre del contrato que se deriva de él.

Ejemplo: En el siguiente ejemplo, el contrato A es heredado por el contrato B, el contrato B es heredado por el contrato C, para demostrar la herencia multinivel.

// Solidity program to
// demonstrate Multi-Level
//  Inheritance
pragma solidity >=0.4.22 <0.6.0; 
 
// Defining parent contract A
contract A { 
 
     // Declaring state variables
     string internal x;
     string a = "Geeks" ;
     string b = "For";
 
    // Defining external function
    // to return concatenated string
    function getA() external{ 
        x = string(abi.encodePacked(a, b));
    } 
} 
 
// Defining child contract B
// inheriting parent contract A
contract B is A { 
 
      // Declaring state variables
      // of child contract B
      string public y;
      string c = "Geeks";
 
    // Defining external function to
    // return concatenated string
    function getB() external payable returns(
      string memory){ 
        y = string(abi.encodePacked(x, c));
    } 
} 
 
// Defining child contract C
// inheriting parent contract A
contract C is B { 
      
    // Defining external function 
    // returning concatenated string
    // generated in child contract B
    function getC() external view returns(
      string memory){ 
        return y; 
    } 
} 
   
// Defining calling contract 
contract caller {
 
    // Creating object of child C
    C cc = new C(); 
 
    // Defining public function to
    // return final concatenated string 
    function testInheritance(
    ) public returns (
      string memory) { 
        cc.getA();
        cc.getB();
        return cc.getC(); 
    } 
}

Producción : 

3. Herencia jerárquica

En la herencia jerárquica, un contrato principal tiene más de un contrato secundario. Se usa principalmente cuando una funcionalidad común se va a usar en diferentes lugares.

Ejemplo: En el siguiente ejemplo, el contrato A es heredado por el contrato B, el contrato A es heredado por el contrato C, lo que demuestra la herencia jerárquica.

// Solidity program to demonstrate
// Hierarchical Inheritance
pragma solidity >=0.4.22 <0.6.0; 
 
// Defining parent contract A 
contract A { 
 
    // Declaring internal
    // state variable
    string internal x;
    
    // Defining external function
    // to set value of
    // internalstate variable
    function getA() external {
        x = "GeeksForGeeks";
    } 
     
    // Declaring internal
    // state variable
    uint internal sum; 
     
    // Defining external function
    // to set the value of
    // internal state variable sum 
    function setA() external { 
        uint a = 10;
        uint b = 20;
        sum = a + b;
    }
}
 
// Defining child contract B
// inheriting parent contract A
contract B is A { 
 
    // Defining external function to
    // return state variable x
    function getAstr(
    ) external view returns(string memory){ 
        return x; 
    } 
     
}
 
 
// Defining child contract C
// inheriting parent contract A
contract C is A { 
 
      // Defining external function to
      // return state variable sum
      function getAValue(
      ) external view returns(uint){ 
        return sum; 
    } 
}
 
// Defining calling contract   
contract caller {
 
    // Creating object of contract B      
    B contractB = new B(); 
 
    // Creating object of contract C
    C contractC = new C();  
     
    // Defining public function to
    // return values of state variables
    // x and sum
    function testInheritance(
    ) public returns (
      string memory, uint) { 
        return (
          contractB.getAstr(), contractC.getAValue()); 
    } 
}

Producción : 

4. Herencia múltiple

En Herencia Múltiple, un solo contrato puede ser heredado de muchos contratos. Un contrato padre puede tener más de un hijo, mientras que un contrato hijo puede tener más de un padre.

Ejemplo: en el siguiente ejemplo, el contrato A es heredado por el contrato B, el contrato C hereda el contrato A y el contrato B, lo que demuestra la herencia múltiple.

// Solidity program to
// demonstrate
// Multiple Inheritance
pragma solidity >=0.4.22 <0.6.0; 
 
// Defining contract A 
contract A {
 
    // Declaring internal
    // state variable
    string internal x;
 
    // Defining external function
    // to set value of
    // internal state variable x
    function setA() external {
        x = "GeeksForGeeks";
    }
}
 
// Defining contract B 
contract B { 
 
    // Declaring internal
   // state variable
    uint internal pow; 
 
    // Defining external function
    // to set value of internal
    // state variable pow
    function setB() external { 
        uint a = 2;
        uint b = 20;
        pow = a ** b;
         
    }
} 
 
// Defining child contract C
// inheriting parent contract
// A and B
contract C is A, B { 
 
  // Defining external function
  // to return state variable x
  function getStr(
  ) external returns(string memory) { 
        return x; 
    }
   
    // Defining external function
    // to return state variable pow
    function getPow(
    ) external returns(uint) { 
        return pow; 
    } 
} 
 
// Defining calling contract
contract caller { 
 
    // Creating object of contract C
    C contractC = new C(); 
   
    // Defining public function to
    // return values from functions
   // getStr and getPow
    function testInheritance(
    ) public returns(string memory, uint) { 
        contractC.setA(); 
        contractC.setB(); 
        return (
          contractC.getStr(), contractC.getPow()); 
    } 
}

Producción :