Lohkoketjun älysopimukset Soliditylla · Oppitunti

Periytyminen ja rajapinnat

Hyödynnä periytymistä koodin uudelleenkäytettävyyteen ja määritä selkeät sopimusrajapinnat parempaa modulaarisuutta varten.

Oppitunti 1/411 vaihetta

Periytyminen ja rajapinnat on ilmainen Lohkoketjun älysopimukset Soliditylla-oppitunti CoddyKitissä. Tämä on oppitunti 1/4. Voit lukea koko oppitunnin alta ilmaiseksi ja harjoitella sen jälkeen käytännössä selaimessa sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla. Oppitunti kuuluu Lohkoketjun älysopimukset Soliditylla-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Lohkoketjun älysopimukset Soliditylla-kurssilla on yhteensä 4 oppituntia.

Mitä periytyminen on?

Solidityssä periytymisen avulla yksi älysopimus (lapsi) voi käyttää uudelleen toisen sopimuksen (vanhemman) koodia, funktioita ja tilamuuttujia. Tämä on olio-ohjelmoinnin keskeinen käsite.

Se edistää koodin uudelleenkäyttöä.
Se auttaa järjestämään monimutkaista sopimuslogiikkaa.
Se mahdollistaa modulaariset ja laajennettavat rakenteet.

Periytymisen perussyntaksi

Jos haluatte sopimuksen perivän toisesta sopimuksesta, käyttäkää is-avainsanaa. Lapsisopimus saa käyttöönsä kaikki vanhemman public- ja internal-jäsenet.

Ajatelkaa tätä lapsena, joka perii ominaisuuksia vanhemmaltaan.

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

Funktioiden ja tilan periyttäminen

Kun ChildContract perii ParentContract-sopimuksen, se saa automaattisesti käyttöönsä arvon parentValue ja funktion getParentValue(). Voit käsitellä niitä suoraan lapsisopimuksesta.

Otetaan ChildContract käyttöön ja tarkastellaan sen vanhemman arvoa!

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

Funktioiden ylikirjoittaminen

Joskus lapsisopimuksen on tarjottava oma toteutuksensa funktiolle, joka on jo olemassa vanhemmassa. Tätä kutsutaan ylikirjoittamiseksi.

Funktion ylikirjoittaminen edellyttää seuraavaa:

Vanhemman funktio on merkittävä määritteellä virtual.
Lapsen funktio on merkittävä määritteellä override.
Funktioiden allekirjoitusten (nimi, parametrit ja palautustyypit) on vastattava täsmälleen toisiaan.

Esimerkki ylikirjoittamisesta

Tässä ChildContract tarjoaa uuden toiminnan funktiolle greet(). Huomaa avainsanat virtual ja 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!";
    }
}

Vanhemman funktioiden kutsuminen komennolla 'super'

Kun ylikirjoitat funktion, sen logiikkaa ei aina tarvitse korvata kokonaan. Voit edelleen kutsua funktion vanhemman version ylikirjoittavan funktion sisältä komennolla super.

Tämä on hyödyllistä, kun haluat laajentaa tai muokata vanhemman toimintaa sen sijaan, että korvaisit sen kokonaan.

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

Mitä rajapinnat ovat?

Solidity-rajapinta on kuin pohjapiirros tai sopimus ilman toteutusta. Se määrittelee julkiset funktiot, jotka sopimuksella täytyy olla, jos se ilmoittaa toteuttavansa kyseisen rajapinnan.

Ne määrittelevät, mitä funktioita on olemassa sekä niiden parametrit ja palautustyypit.
Ne eivät sisällä funktioiden runkoja eivätkä tilamuuttujia.
Kaikki rajapinnan funktiot ovat implisiittisesti external-funktioita.

Rajapinnan syntaksi ja tarkoitus

Rajapinnat määritellään avainsanalla interface. Ne ovat olennaisia seuraavissa asioissa:

Standardointi: Varmistetaan, että sopimukset noudattavat tiettyjä julkisia ohjelmointirajapintoja (esimerkiksi ERC-20-tokenistandardia).
Yhteentoimivuus: Sopimukset voivat olla vuorovaikutuksessa muiden sopimusten kanssa tuntematta niiden koko toteutusta, sillä ne tarvitsevat tietää vain rajapinnan.
Modulaarisuus: Sopimusten rakenteet voidaan irrottaa toisistaan.

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

Rajapinnan toteuttaminen

Sopimus voi toteuttaa rajapinnan avainsanalla is samalla tavalla kuin perinnässä. Kun sopimus toteuttaa rajapinnan, sen täytyy tarjota konkreettiset toteutukset kaikille rajapinnassa määritellyille funktioille.

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

Pikatarkistus: perintä vai rajapinta

Mikä seuraavista Solidity-perintää ja -rajapintoja koskevista väitteistä on TOSI?

Vastaa interaktiivisessa oppitunnissa

Kertaus: perintä ja rajapinnat

Olemme tutustuneet kahteen tehokkaaseen Solidity-konseptiin modulaaristen ja uudelleenkäytettävien älysopimusten rakentamisessa:

Perintä: Lapsisopimus voi käyttää vanhemman koodia ja logiikkaa uudelleen avainsanalla is. Vanhemman funktiot voidaan merkitä määritteellä virtual ja lapsen funktiot määritteellä override, ja super-komennolla voidaan kutsua vanhemman logiikkaa.
Rajapinnat: Ne määrittelevät sopimuksen julkisen ohjelmointirajapinnan toteuttamatta sen logiikkaa. Niissä käytetään avainsanaa interface, ja ne varmistavat, että sopimukset noudattavat tiettyjä funktioiden allekirjoituksia, mikä edistää standardointia ja yhteentoimivuutta.

Näiden mallien hallinta on olennaista vankan ja ylläpidettävän Solidity-koodin kirjoittamisessa!

Aloita maksutta

Opi Lohkoketjun älysopimukset Soliditylla tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 12
Oppitunnit: 48

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Periytyminen ja rajapinnat” ilmainen?

Kyllä – oppitunnin ”Periytyminen ja rajapinnat” koko tekstin voi lukea täällä verkossa ilmaiseksi. Jos haluat harjoitella interaktiivisesti sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla sekä avata koko Lohkoketjun älysopimukset Soliditylla-kurssin, päivitä CoddyKit PROhon. Lohkoketjun älysopimukset Soliditylla-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”Periytyminen ja rajapinnat”?

Hyödynnä periytymistä koodin uudelleenkäytettävyyteen ja määritä selkeät sopimusrajapinnat parempaa modulaarisuutta varten. Harjoittelet Lohkoketjun älysopimukset Soliditylla-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni Lohkoketjun älysopimukset Soliditylla-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin Lohkoketjun älysopimukset Soliditylla-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 1/4.

Kuinka kauan ”Periytyminen ja rajapinnat”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä Lohkoketjun älysopimukset Soliditylla-oppitunnilla?

Kyllä. Jokainen Lohkoketjun älysopimukset Soliditylla-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

Periytyminen ja rajapinnat
Kirjastot ja abstraktit sopimukset
Virheenkäsittely Revertillä ja Requirella
Modifioijat ja checks-effects-interactions-malli

← Takaisin: Lohkoketjun älysopimukset Soliditylla