Blokkjede-smartkontrakter med Solidity · leksjon

Arv og grensesnitt

Bruk arv for å gjenbruke kode, og definer tydelige kontrakt-API-er med grensesnitt for bedre modularitet.

Leksjon 1 av 411 trinn

Arv og grensesnitt er en gratis leksjon i Blokkjede-smartkontrakter med Solidity på CoddyKit. Dette er leksjon 1 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Blokkjede-smartkontrakter med Solidity, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Blokkjede-smartkontrakter med Solidity inneholder totalt 4 leksjoner.

Hva er arv?

I Solidity lar arv én smartkontrakt ( underkontrakten ) gjenbruke kode, funksjoner og tilstandsvariabler fra en annen kontrakt ( overkontrakten ). Dette er et grunnleggende konsept innen objektorientert programmering.

Det fremmer gjenbruk av kode.
Det bidrar til å organisere kompleks kontraktslogikk.
Det muliggjør modulære og utvidbare utforminger.

Grunnleggende syntaks for arv

For å la en kontrakt arve fra en annen bruker De nøkkelordet is. Underkontrakten får tilgang til alle public- og internal-medlemmer i overkontrakten.

Tenk på det som at et barn arver egenskaper fra forelderen sin.

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()
}

Arve funksjoner og tilstand

Når ChildContract arver fra ParentContract, får den automatisk tilgang til parentValue og funksjonen getParentValue(). De kan brukes direkte fra den underordnede kontrakten.

La oss distribuere ChildContract og se verdien fra foreldrekontrakten!

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
    }
}

Overstyring av funksjoner

Noen ganger trenger en underordnet kontrakt å tilby sin egen implementasjon av en funksjon som allerede finnes i foreldrekontrakten. Dette kalles overstyring.

Slik overstyrer De en funksjon:

Funksjonen i foreldrekontrakten må merkes med virtual.
Funksjonen i den underordnede kontrakten må merkes med override.
Funksjonssignaturene (navn, parametere og returtyper) må være helt like.

Eksempel på overstyring

Her tilbyr ChildContract en ny oppførsel for greet(). Legg merke til nøkkelordene virtual og override.

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!";
    }
}

Kalle foreldrefunksjoner med 'super'

Når De overstyrer en funksjon, trenger De ikke alltid å erstatte logikken fullstendig. De kan fortsatt kalle foreldrekontraktens versjon av funksjonen fra den overstyrende funksjonen ved hjelp av super.

Dette er nyttig når De vil utvide eller endre oppførselen i foreldrekontrakten i stedet for å erstatte den helt.

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"));
    }
}

Hva er grensesnitt?

Et Solidity-grensesnitt er som en skisse eller en kontrakt uten implementasjon. Det definerer de offentlige funksjonene som en kontrakt må ha hvis den hevder å implementere grensesnittet.

De angir hvilke funksjoner som finnes, samt parametere og returtyper.
De inneholder ingen funksjonskropper eller tilstandsvariabler.
Alle funksjoner i et grensesnitt er implisitt external.

Syntaks og formål for grensesnitt

Grensesnitt deklareres ved hjelp av nøkkelordet interface. De er avgjørende for:

Standardisering: Å sikre at kontrakter følger bestemte offentlige API-er, for eksempel ERC-20-tokenstandarden.
Samhandling: Å la kontrakter samhandle med andre kontrakter uten å kjenne detaljene i implementasjonen, men bare grensesnittet.
Modularitet: Å frikoble kontraktdesign.

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);
}

Implementere et grensesnitt

En kontrakt kan implementere et grensesnitt ved hjelp av nøkkelordet is, på samme måte som ved arv. Når en kontrakt implementerer et grensesnitt, må den tilby konkrete implementasjoner av alle funksjonene som er deklarert i grensesnittet.

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;
    }
}

Kort kontroll: Arv kontra grensesnitt

Hvilket av følgende utsagn om Solidity-arv og grensesnitt er SANT?

Besvar den i den interaktive leksjonen

Oppsummering: Arv og grensesnitt

Vi har utforsket to kraftige konsepter i Solidity for å bygge modulære og gjenbrukbare smartkontrakter:

Arv: Lar en underordnet kontrakt gjenbruke kode og logikk fra en foreldrekontrakt ved hjelp av nøkkelordet is. Funksjoner kan være virtual i foreldrekontrakten og override i den underordnede kontrakten, og super kan kalle logikk fra foreldrekontrakten.
Grensesnitt: Definerer en kontrakts offentlige API uten å implementere logikken. De bruker nøkkelordet interface og sikrer at kontrakter følger bestemte funksjonssignaturer, noe som fremmer standardisering og samhandling.

Å beherske disse mønstrene er viktig for å skrive robust og vedlikeholdbar Solidity-kode!

Gratis å komme i gang

Lær deg Blokkjede-smartkontrakter med Solidity med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 12
Leksjoner: 48

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Arv og grensesnitt» gratis?

Ja – hele teksten i «Arv og grensesnitt» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Blokkjede-smartkontrakter med Solidity-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Blokkjede-smartkontrakter med Solidity inneholder totalt 4 leksjoner.

Hva lærer jeg i «Arv og grensesnitt»?

Bruk arv for å gjenbruke kode, og definer tydelige kontrakt-API-er med grensesnitt for bedre modularitet. Du øver på Blokkjede-smartkontrakter med Solidity med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Blokkjede-smartkontrakter med Solidity?

Ingen tidligere erfaring er nødvendig. Blokkjede-smartkontrakter med Solidity på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.

Hvor lang tid tar leksjonen «Arv og grensesnitt»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Blokkjede-smartkontrakter med Solidity-leksjonen?

Ja. Alle Blokkjede-smartkontrakter med Solidity-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Blokkjede-smartkontrakter med Solidity