Day 21 - Single Inheritance

This is Day 21 of 30 in Solidity Series
Today I Learned About Single Inheritance in Solidity.

Inheritance is one of the most important features of the object-oriented programming language. It is a way of extending the functionality of a program, used to separate the code, reduces the dependency, and increases the re-usability of the existing code. Solidity supports inheritance between smart contracts, where multiple contracts can be inherited into a single contract. The contract from which other contracts inherit features is known as a base contract, while the contract which inherits the features is called a derived contract. Simply, they are referred to as parent-child contracts. The scope of inheritance in Solidity is limited to public and internal modifiers only. Some of the key highlights of Solidity are:

• A derived contract can access all non-private members including state variables and internal methods. But using this is not allowed.
• Function overriding is allowed provided function signature remains the same. In case of the difference of output parameters, the compilation will fail.
• We can call a super contract’s function using a super keyword or using a super contract name.
• In the case of multiple inheritances, function calls using super gives preference to most derived contracts.

Solidity provides different types of inheritance.

Single Inheritance

In Single or single level inheritance the functions and variables of one base contract are inherited to only one derived contract.

Example: In the below example, the contract parent is inherited by the contract child, to demonstrate Single Inheritance.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;

// Defining contract
contract parent {
    uint256 internal sum;

    function setValue() external {
        uint256 a = 10;
        uint256 b = 20;
        sum = a + b;
    }
}

// Defining child contract
contract child is parent {
    function getValue() external view returns (uint256) {
        return sum;
    }
}

// Defining calling contract
contract caller {
    child cc = new child();

    // Defining function to call setValue and getValue functions
    function testInheritance() public returns (uint256) {
        cc.setValue();
        return cc.getValue();
    }
}

Output:

when we call the testInheritance function, the output is 30.