What is Inheritance in Solidity: Explained with Example

In Solidity, inheritance allows one contract to reuse code from another contract, making it easier to build on existing functionality. It works like a family tree where a child contract inherits properties and functions from a parent contract.

How It Works

Inheritance in Solidity works by letting one contract (called the child) take all the variables and functions from another contract (called the parent). Think of it like a child inheriting traits from their parents in real life, such as eye color or height. Here, the child contract inherits code, so you don’t have to write the same code again.

This helps keep your code clean and organized. If you want to add or change something, you can do it in the child contract without touching the parent. Solidity supports multiple inheritance, meaning a contract can inherit from more than one parent, combining their features.

Example

This example shows a parent contract with a greeting function and a child contract that inherits it and adds its own function.

solidity

pragma solidity ^0.8.0;

contract Parent {
    string public greeting = "Hello from Parent!";

    function sayHello() public view returns (string memory) {
        return greeting;
    }
}

contract Child is Parent {
    function sayChild() public pure returns (string memory) {
        return "Hello from Child!";
    }
}

When to Use

Use inheritance in Solidity when you want to build new contracts that share common features with existing ones. It saves time and reduces mistakes by reusing tested code. For example, you might have a base contract for user management and create different child contracts for various user roles.

Inheritance is also useful for upgrading contracts or adding new features without rewriting everything. It helps organize complex projects by breaking them into smaller, reusable parts.

Key Points

• Inheritance lets contracts reuse code from other contracts.
• Child contracts get all public and internal variables and functions from parents.
• Supports multiple inheritance to combine features.
• Keeps code clean, organized, and easier to maintain.
• Useful for building complex contracts from simple parts.

Key Takeaways

Inheritance in Solidity allows contracts to reuse code from other contracts.

It helps keep your code organized and reduces duplication.

Child contracts inherit all public and internal variables and functions from parent contracts.

Multiple inheritance lets you combine features from several contracts.

Use inheritance to build scalable and maintainable smart contracts.