Blockchain Smart Contracts with Solidity · 课时

继承与接口

利用继承实现代码复用，并使用接口定义清晰的合约 API，提升模块化程度。

继承与接口 是 CoddyKit 上的免费 Blockchain Smart Contracts with Solidity 课时。这是第 1 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Blockchain Smart Contracts with Solidity 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Blockchain Smart Contracts with Solidity 课程共包含 4 节课。

本课时的部分内容尚未翻译，以英文显示。

What is Inheritance?

In Solidity, inheritance allows one smart contract (the child) to reuse code, functions, and state variables from another contract (the parent). This is a fundamental concept in object-oriented programming.

It promotes code reusability.
It helps organize complex contract logic.
It allows for modular and extensible designs.

Basic Inheritance Syntax

To make a contract inherit from another, you use the is keyword. The child contract gets access to all public and internal members of the parent contract.

Think of it like a child inheriting traits from its parent.

pragma solidity ^0.8.0;

contract ParentContract {
    uint public parentValue;

    constructor() {
        parentValue = 100;
    }

    function getParentValue() public view returns (uint) {
        return parentValue;
    }
}

contract ChildContract is ParentContract {
    // ChildContract inherits parentValue and getParentValue()
}

Inheriting Functions & State

When ChildContract inherits from ParentContract, it automatically gains access to parentValue and the getParentValue() function. You can directly interact with them from the child contract.

Let's deploy ChildContract and see its parent's value!

pragma solidity ^0.8.0;

contract ParentContract {
    uint public parentValue;

    constructor() {
        parentValue = 100;
    }

    function getParentValue() public view returns (uint) {
        return parentValue;
    }
}

contract ChildContract is ParentContract {
    function getMyParentValue() public view returns (uint) {
        return getParentValue(); // Calling an inherited function
    }

    function getDirectParentValue() public view returns (uint) {
        return parentValue; // Accessing an inherited state variable
    }
}

Overriding Functions

Sometimes, a child contract needs to provide its own implementation for a function that already exists in the parent. This is called overriding.

To override a function:

The parent function must be marked with virtual.
The child function must be marked with override.
Function signatures (name, parameters, return types) must match exactly.

Override Example

Here, the ChildContract provides a new behavior for greet(). Notice the virtual and override keywords.

pragma solidity ^0.8.0;

contract GreeterParent {
    function greet() public virtual view returns (string memory) {
        return "Hello from Parent!";
    }
}

contract GreeterChild is GreeterParent {
    function greet() public override view returns (string memory) {
        return "Hello from Child!";
    }
}

Calling Parent Functions with 'super'

When you override a function, you don't always have to completely replace its logic. You can still call the parent's version of the function within the overriding function using super.

This is useful for extending or modifying parent behavior instead of replacing it entirely.

pragma solidity ^0.8.0;

contract Base {
    function foo() public virtual pure returns (string memory) {
        return "Base foo";
    }
}

contract Derived is Base {
    function foo() public override pure returns (string memory) {
        string memory baseMessage = super.foo(); // Call parent's foo()
        return string(abi.encodePacked(baseMessage, " and Derived logic"));
    }
}

What are Interfaces?

A Solidity Interface is like a blueprint or a contract without any implementation. It defines the public functions that a contract must have if it claims to implement that interface.

They specify what functions exist and their parameters/return types.
They do not contain any function bodies or state variables.
All functions in an interface are implicitly external.

Interface Syntax & Purpose

Interfaces are declared using the interface keyword. They are crucial for:

Standardization: Ensuring contracts adhere to specific public APIs (e.g., ERC-20 token standard).
Interoperability: Allowing contracts to interact with other contracts without knowing their full implementation details, only their interface.
Modularity: Decoupling contract designs.

pragma solidity ^0.8.0;

interface ICalculator {
    function add(uint a, uint b) external pure returns (uint);
    function subtract(uint a, uint b) external pure returns (uint);
}

Implementing an Interface

A contract can implement an interface using the is keyword, similar to inheritance. When a contract implements an interface, it must provide concrete implementations for all functions declared in that interface.

pragma solidity ^0.8.0;

interface IGreeter {
    function greet() external view returns (string memory);
    function setGreeting(string calldata _greeting) external;
}

contract MyGreeter is IGreeter {
    string private currentGreeting = "Hello, World!";

    function greet() public view override returns (string memory) {
        return currentGreeting;
    }

    function setGreeting(string calldata _greeting) public override {
        currentGreeting = _greeting;
    }
}

Quick Check: Inheritance vs. Interface

Which of the following statements about Solidity inheritance and interfaces is TRUE?

Recap: Inheritance & Interfaces

We've explored two powerful concepts in Solidity for building modular and reusable smart contracts:

Inheritance: Allows a child contract to reuse code and logic from a parent using the is keyword. Functions can be virtual in the parent and override in the child, and super can call parent logic.
Interfaces: Define a contract's public API without implementing its logic. They use the interface keyword and ensure contracts adhere to specific function signatures, promoting standardization and interoperability.

Mastering these patterns is key to writing robust and maintainable Solidity code!

常见问题解答

「继承与接口」课时是免费的吗？

是的 — 「继承与接口」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Blockchain Smart Contracts with Solidity 课程的其余内容，请升级到 CoddyKit PRO。 Blockchain Smart Contracts with Solidity 课程共包含 4 节课。

「继承与接口」这节课中我会学到什么？

利用继承实现代码复用，并使用接口定义清晰的合约 API，提升模块化程度。你通过在浏览器中直接运行的动手代码来练习 Blockchain Smart Contracts with Solidity，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Blockchain Smart Contracts with Solidity 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Blockchain Smart Contracts with Solidity 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 1 节课，共 4 节。

「继承与接口」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Blockchain Smart Contracts with Solidity 课中编写并运行代码吗？

能。每节 Blockchain Smart Contracts with Solidity 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 Blockchain Smart Contracts with Solidity