Why inheritance promotes code reuse in Blockchain / Solidity - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to inherit properties from the parent contract.

Blockchain / Solidity

contract Child is [1] {
    // Child contract code
}

Drag options to blanks, or click blank then click option'

AParent

BChild

CBase

DContract

Attempts:

3 left

💡 Hint

Common Mistakes

Using the child contract's own name instead of the parent.

Forgetting to specify the parent contract name.

The child contract inherits from the Parent contract to reuse its code.

2fill in blank

medium

Complete the code to call the parent constructor in the child contract.

Blockchain / Solidity

contract Child is Parent {
    constructor() [1] {
        Parent();
        // Initialization
    }
}

Drag options to blanks, or click blank then click option'

Ainternal

Bpublic

Cexternal

Doverride

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'override' keyword incorrectly.

Setting constructor visibility to external.

The child constructor must be public to call the parent's constructor properly.

3fill in blank

hard

Fix the error in overriding the parent function in the child contract.

Blockchain / Solidity

contract Child is Parent {
    function greet() [1] override returns (string memory) {
        return "Hello from Child!";
    }
}

Drag options to blanks, or click blank then click option'

Avirtual

Boverride

Cpublic

Dexternal

Attempts:

3 left

💡 Hint

Common Mistakes

Placing 'override' as visibility.

Missing 'override' keyword after visibility.

The function visibility must be public to correctly override the parent's function.

4fill in blank

hard

Fill both blanks to define a function in the parent contract that can be overridden by the child.

Blockchain / Solidity

contract Parent {
    function greet() public [1] returns (string memory) {
        return "Hello from Parent!";
    }
}

contract Child is Parent {
    function greet() public [2] returns (string memory) {
        return "Hello from Child!";
    }
}

Drag options to blanks, or click blank then click option'

Avirtual

Boverride

Cexternal

Dinternal

Attempts:

3 left

💡 Hint

Common Mistakes

Forgetting 'virtual' in parent function.

Not using 'override' in child function.

The parent function must be marked virtual to allow overriding, and the child function must use override.

5fill in blank

hard

Fill all three blanks to create a reusable modifier in the parent and apply it in the child contract.

Blockchain / Solidity

contract Parent {
    modifier onlyOwner() [1] {
        require(msg.sender == owner, "Not owner");
        _;
    }
}

contract Child is Parent {
    function secureAction() [2] [3] onlyOwner {
        // secure code
    }
}

Drag options to blanks, or click blank then click option'

Apublic

Bvirtual

Coverride

Dinternal

Attempts:

3 left

💡 Hint

Common Mistakes

Making modifier public.

Missing 'override' keyword in child function.

Wrong function visibility.

The modifier is usually internal. The child function is public and uses override if it overrides a parent function.

Practice

1. Why does inheritance promote code reuse in blockchain smart contracts?

easy

A. It allows new contracts to use existing code without rewriting it

B. It makes contracts run faster on the blockchain

C. It encrypts the contract code automatically

D. It prevents contracts from being copied

Solution

1. Step 1: Understand inheritance concept

   Inheritance lets a new contract use code from an existing contract, avoiding rewriting.

2. Step 2: Identify how this saves effort

   By reusing code, developers save time and reduce errors, making maintenance easier.

3. Final Answer:

   It allows new contracts to use existing code without rewriting it -> Option A

4. Quick Check:

   Inheritance = reuse code [OK]

Hint: Inheritance means reuse existing code easily [OK]

Common Mistakes:

• Thinking inheritance speeds up contract execution
• Confusing inheritance with encryption
• Believing inheritance blocks code copying

2. Which of the following is the correct Solidity syntax to inherit from a contract named BaseContract?

easy

A. contract NewContract inherits BaseContract {}

B. contract NewContract from BaseContract {}

C. contract NewContract extends BaseContract {}

D. contract NewContract is BaseContract {}

Solution

1. Step 1: Recall Solidity inheritance syntax

   Solidity uses is keyword to inherit from another contract.

2. Step 2: Match syntax with options

   contract NewContract is BaseContract {} uses is correctly; others use invalid keywords.

3. Final Answer:

   contract NewContract is BaseContract {} -> Option D

4. Quick Check:

   Solidity inheritance uses 'is' [OK]

Hint: Remember Solidity uses 'is' for inheritance [OK]

Common Mistakes:

• Using 'inherits' or 'extends' instead of 'is'
• Forgetting curly braces after contract declaration
• Mixing syntax from other languages

3. Given the following Solidity code, what will be the output of getValue() when called on Child contract?

contract Parent {
    function getValue() public pure returns (string memory) {
        return "Parent";
    }
}

contract Child is Parent {
    function getValue() public pure returns (string memory) {
        return "Child";
    }
}

medium

A. "Parent"

B. "Child"

C. Compilation error due to duplicate function

D. Runtime error

Solution

1. Step 1: Understand function overriding in inheritance

   The Child contract overrides getValue() from Parent.

2. Step 2: Determine which function runs on Child

   Calling getValue() on Child runs the overridden version returning "Child".

3. Final Answer:

   "Child" -> Option B

4. Quick Check:

   Override method runs in child contract [OK]

Hint: Child overrides parent method, so child's version runs [OK]

Common Mistakes:

• Assuming parent method runs instead of child's
• Thinking duplicate functions cause compile error
• Confusing runtime errors with override behavior

4. Identify the error in this Solidity inheritance code:

contract A {
    uint public x = 5;
}

contract B is A {
    uint public x = 10;
}

medium

A. Variable x is redeclared in child contract causing shadowing

B. Missing constructor in child contract

C. Incorrect inheritance keyword used

D. No error, code is correct

Solution

1. Step 1: Check variable declarations in parent and child

   Both A and B declare x, causing shadowing.

2. Step 2: Understand shadowing issue

   Child's x hides parent's x, which can cause confusion or bugs.

3. Final Answer:

   Variable x is redeclared in child contract causing shadowing -> Option A

4. Quick Check:

   Variable redeclaration causes shadowing [OK]

Hint: Avoid redeclaring variables in child contracts [OK]

Common Mistakes:

• Ignoring variable shadowing effects
• Thinking constructors are mandatory for inheritance
• Confusing inheritance keyword syntax

5. You want to create a smart contract that reuses code from two existing contracts, Token and Ownable. Which approach best promotes code reuse and avoids duplication?

hard

A. Write new code that mimics Token and Ownable functions

B. Copy all code from Token and Ownable into the new contract

C. Create a new contract that inherits from both Token and Ownable

D. Deploy Token and Ownable separately and call them externally

Solution

1. Step 1: Understand multiple inheritance in Solidity

   Solidity supports inheriting from multiple contracts to reuse their code.

2. Step 2: Compare options for code reuse

   Inheriting from both Token and Ownable avoids duplication and keeps code organized.

3. Final Answer:

   Create a new contract that inherits from both Token and Ownable -> Option C

4. Quick Check:

   Multiple inheritance promotes reuse best [OK]

Hint: Use multiple inheritance to combine existing contracts [OK]

Common Mistakes:

• Copy-pasting code instead of inheriting
• Rewriting code manually causing errors
• Ignoring Solidity's multiple inheritance feature