Pewarisan dan Antarmuka
Manfaatkan pewarisan untuk penggunaan ulang kode dan definisikan API kontrak yang jelas menggunakan antarmuka demi modularitas yang lebih baik.
Pewarisan dan Antarmuka adalah pelajaran Blockchain Smart Contracts with Solidity gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Blockchain Smart Contracts with Solidity, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Blockchain Smart Contracts with Solidity mencakup 4 pelajaran total.
Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.
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
iskeyword. Functions can bevirtualin the parent andoverridein the child, andsupercan call parent logic. - Interfaces: Define a contract's public API without implementing its logic. They use the
interfacekeyword and ensure contracts adhere to specific function signatures, promoting standardization and interoperability.
Mastering these patterns is key to writing robust and maintainable Solidity code!
Belajar Blockchain Smart Contracts with Solidity dengan tutor AI — gratis
Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.
- Kursus
- 12
- Pelajaran
- 48
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Pewarisan dan Antarmuka” gratis?
Ya — teks lengkap “Pewarisan dan Antarmuka” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Blockchain Smart Contracts with Solidity, upgrade ke CoddyKit PRO. Kursus Blockchain Smart Contracts with Solidity mencakup 4 pelajaran total.
Apa yang akan aku pelajari di “Pewarisan dan Antarmuka”?
Manfaatkan pewarisan untuk penggunaan ulang kode dan definisikan API kontrak yang jelas menggunakan antarmuka demi modularitas yang lebih baik. Kamu berlatih Blockchain Smart Contracts with Solidity dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.
Apakah aku perlu pengalaman untuk memulai Blockchain Smart Contracts with Solidity?
Tidak diperlukan pengalaman sebelumnya. Blockchain Smart Contracts with Solidity di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.
Berapa lama pelajaran “Pewarisan dan Antarmuka” memakan waktu?
Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.
Bisakah aku menulis dan menjalankan kode dalam pelajaran Blockchain Smart Contracts with Solidity ini?
Ya. Setiap pelajaran Blockchain Smart Contracts with Solidity menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.
Semua pelajaran dalam kursus ini
- Pewarisan dan Antarmuka
- Pustaka dan Kontrak Abstrak
- Penanganan Error dengan Revert/Require
- Modifier dan Pola Checks-Effects-Interactions