Interview Bite

In Solidity, inheritance allows a contract to inherit properties and functions from another contract. This promotes code reusability and modularity.

Syntax:

contract ChildContract is ParentContract {
    // ...
}

Example:

contract Animal {
    function makeSound() public virtual {
        // Default implementation
    }
}

contract Dog is Animal {
    function makeSound() public override {
        // Specific implementation for dogs
    }
}

Key Points:

• The is keyword is used to indicate inheritance.
• The override keyword is used to override a function from the parent contract.
• Solidity supports single inheritance.

Abstract Classes

Abstract classes are contracts that cannot be instantiated directly. They are used as base classes for other contracts. Abstract classes must contain at least one abstract function.

Syntax:

abstract contract AbstractContract {
    abstract function myAbstractFunction() public pure;
}

Example:

abstract contract Shape {
    abstract function area() public pure returns (uint);
}

contract Circle is Shape {
    uint public radius;

    function area() public pure override returns (uint) {
        // Calculate area of a circle
    }
}

Key Points:

• Abstract classes cannot be instantiated directly.
• Abstract classes must contain at least one abstract function.
• Abstract functions are declared without a body.

Benefits of Inheritance and Abstract Classes

Code reusability: Avoids code duplication by inheriting common functionality from base classes.

Modularity: Encourages a modular design by breaking down complex contracts into smaller, more manageable components.

Polymorphism: Allows different derived classes to implement abstract functions in their own ways.

Best Practices

Use inheritance judiciously. Overuse of inheritance can lead to complex and hard-to-maintain code.

Use abstract classes to define common interfaces and enforce specific behavior in derived classes.

Consider using interfaces instead of abstract classes in some cases, especially when you only need to define a contract’s public interface without providing any implementation.