Inheritance

In Solidity, inheritance is a mechanism that allows you to reuse code and extend the functionality of contracts by creating new contracts that are derived from existing ones. Inheritance is a key concept in programming that allows you to create more complex and powerful contracts by building upon the code and functionality of existing contracts. In this article, we’ll take a closer look at inheritance in Solidity, including how to create derived contracts, how to access and override inherited functions, and how to use the “super” keyword to call inherited functions from derived contracts.

Defining Base Contracts

In Solidity, base contracts are contracts that are used as the foundation for derived contracts. Base contracts contain the code and functionality that will be inherited by the derived contracts.

To define a base contract, use the “contract” keyword followed by the contract name and a set of curly braces containing the contract’s code and functionality. For example:

contract BaseContract {
  function baseFunction() public {
    console.log("This is a base function.");
  }
}

This code defines a base contract called “BaseContract” with a single function called “baseFunction” that prints a message to the console.

Creating Derived Contracts

To create a derived contract in Solidity, use the “contract” keyword followed by the contract name and the “is” keyword, and then the name of the base contract. The derived contract’s code and functionality is defined within a set of curly braces as usual.

For example, the following code defines a derived contract called “DerivedContract” that is based on the “BaseContract” base contract:

contract DerivedContract is BaseContract {
  function derivedFunction() public {
    console.log("This is a derived function.");
  }
}

This code defines a derived contract called “DerivedContract” with a single function called “derivedFunction” that prints a message to the console. The “DerivedContract” contract also inherits the “baseFunction” function from the “BaseContract” base contract.

Accessing and Overriding Inherited Functions

In Solidity, derived contracts have access to all of the functions and variables of their base contracts. To access an inherited function, use the contract name followed by the function name.

For example:

DerivedContract d = new DerivedContract();
d.baseFunction();

This code creates a new instance of the “DerivedContract” contract called “d”, and then calls the “baseFunction” function of the “BaseContract” base contract.

In some cases, you may want to override an inherited function in a derived contract. To override an inherited function, define a function with the same name and signature in the derived contract. The function in the derived contract will replace the inherited function and will be called instead of the inherited function when the function is called on an instance of the derived contract.

For example:

contract DerivedContract is BaseContract {
  function baseFunction() public {
    console.log("This is an overridden function.");
  }
}

This code defines a derived contract called “DerivedContract” that overrides the “baseFunction” function of the “BaseContract” base contract. When the “baseFunction” function is called on an instance of the “DerivedContract” contract, the overridden function will be called instead of the inherited function.

Using the “super” Keyword

In Solidity, the “super” keyword can be used to call an inherited function from within a derived contract. The “super” keyword is useful for calling inherited functions and then adding additional functionality to the derived contract.

For example:

contract DerivedContract is BaseContract {
  function baseFunction() public {
    super.baseFunction();
    console.log("This is an extended function.");
  }
}

This code defines a derived contract called “DerivedContract” that extends the “baseFunction” function of the “BaseContract” base contract. When the “baseFunction” function is called on an instance of the “DerivedContract” contract, the inherited “baseFunction” function will be called first using the “super” keyword, and then the additional functionality of the derived contract will be executed.

Conclusion

In conclusion, inheritance in Solidity is a powerful mechanism for reusing code and extending the functionality of contracts. Inheritance allows you to create more complex and powerful contracts by building upon the code and functionality of existing contracts, and it allows you to override inherited functions and extend them using the “super” keyword. Understanding inheritance is an important aspect of developing contracts and decentralized applications in Solidity.

Exercises

To review these concepts, we will go through a series of exercises designed to test your understanding and apply what you have learned.