Rustilta puuttuu alkuperäinen tuki OOP: lle, mutta voit käyttää näitä tekniikoita paradigman hyödyntämiseen joka tapauksessa.

Object-Oriented Programming (OOP) yksinkertaistaa ohjelmistojen suunnittelua korostamalla objektien käyttöä edustamaan todellisia kokonaisuuksia ja käsitteitä. OOP edistää ylläpidettävyyttä kapseloimalla toimintoja objekteihin.

Rust on joustava kieli, joka tukee toiminnallista ja prosessiohjelmointia. Vaikka se ei tue olio-ohjelmointia natiivisti, voit toteuttaa OOP-konsepteja käyttämällä Rustin sisäänrakennettuja tietotyyppejä.

Kapselointi ruosteeseen

Kapselointi tarkoittaa koodin järjestämistä itsenäisiksi yksiköiksi, jotka piilottavat sisäiset yksityiskohdat julkisen käyttöliittymän paljastaminen ulkoiselle vuorovaikutukselle monimutkaisuuden minimoimiseksi ja koodin parantamiseksi huollettavuus.

Voit kapseloida Rust-koodin moduuleilla. Moduuli on kokoelma kohteita, jotka sisältävät funktioita, rakenteita, enumeita ja vakioita. Ruostemoduulit tarjoavat toimintoja ohjelman osien ryhmittelyyn ja rajojen määrittämiseen.

instagram viewer

Moduulien käyttö tietojen ja funktioiden kapseloimiseen

Voit määrittää moduulin käyttämällä mod avainsana ja nimi:

mod my_module {
// moduulikohteet menevät tänne
}

Voit järjestää moduulit hierarkkisesti upottamalla niiden ilmoitukset:

mod vanhempi_moduuli {
mod my_module {
// moduulikohteet menevät tänne
 }
}

Voit sitten viitata sisäkkäisiin moduuleihin koko hierarkialla erottamalla kunkin moduulin kaksoispisteellä, esimerkiksi vanhempi_moduuli:: oma_moduuli.

Oletusarvoisesti moduulien kohteet ovat yksityisiä ja niihin pääsee vain koodi samassa moduulissa. Mutta voit tehdä moduuleista julkisia käyttämällä pub avainsana:

mod my_module {
pubfnmy_function() {
// Function body menee tähän
 }
}

Sitten voit käyttää my_function ohjelmasi muista osista.

Ominaisuuksien käyttäminen käyttäytymisen määrittelemiseen

Toinen tapa, jolla Rust mahdollistaa kapseloinnin, on ominaisuuksien käyttö. Ominaisuudet määrittelevät käyttäytymisen, jonka tyypit voivat toteuttaa, ja varmistavat, että eri tyypit noudattavat samaa käyttöliittymää.

pubpiirreTulostettava {
fnTulosta(&itse);
}
pubstructMinun tyyppini {
// Rakenna kentät tähän
}
impl Tulostettava varten Minun tyyppini {
fnTulosta(&itse) {
// toteutus täällä
 }
}

The Tulostettava piirteellä on a Tulosta menetelmä ja Minun tyyppini struct toteuttaa Tulostettava ominaisuus toteuttamalla Tulosta menetelmä.

Ominaisuuksia käyttämällä voit varmistaa, että mikä tahansa tyyppi, joka toteuttaa Tulostettava piirteellä on a Tulosta menetelmä. Tämä on kätevää, kun työskentelet yleisen koodin kanssa, jonka on toimittava yhdessä eri tyyppien kanssa, joilla on yhteinen toimintatapa.

Perintö ruosteessa

Perinnön avulla voit määrittää yhden luokan toisen luokan perusteella. Alaluokka perii yläluokkansa ominaisuudet ja menetelmät.

Rustissa sinua rohkaistaan ​​käyttämään koostumusta perinnön sijasta. Komponentti on prosessi, jossa luodaan uusia objekteja yhdistämällä olemassa olevia. Sen sijaan, että luot uuden luokan, joka perii toiminnallisuuden perusluokasta, voit luoda uuden rakenteen, joka sisältää perusrakenteen esiintymän ja sen kentät.

Uusien tyyppien luominen yhdistämällä olemassa olevia tyyppejä

Käytät enumeita ja rakenteita luodaksesi uusia tyyppejä. Enumit ovat käteviä tyypeille, joilla on rajalliset arvot, ja rakenteet voivat sisältää useita kenttiä.

Voit luoda enum-tyypin erilaisille eläimille.

enumEläin {
 Kissa,
 Koira,
 Lintu,
// ...
}

Vaihtoehtoisesti voit luoda rakenteen, joka sisältää kentät kullekin eläintyypille. Rakenteisiin mahtuu enumeja ja muita tyyppejä.

structEläin {
 nimi: merkkijono,
 ikä: u8,
 animal_type: AnimalType,
}
enumAnimalType {
 Kissa,
 Koira,
 Lintu,
// ...
}

The Eläin struct sisältää arvot AnimalType luettelointityyppi.

Voit käyttää ominaisuuksia periytymisen toteuttamiseen ja käyttäytymisen lisäämiseen tyypille luomatta uutta.

piirreLentää {
fnlentää(&itse);
}

Näin voit toteuttaa Lentää ominaisuus useille tyypeille.

structLintu {
 nimi: merkkijono,
 siipien kärkiväli: f32,
}
impl Lentää varten Lintu {
fnlentää(&itse) {
println!("{} lentää!", itse.nimi);
 }
}


structLentokone {
 malli: merkkijono,
 maksiminopeus: u32,
}
impl Lentää varten Lentokone {
fnlentää(&itse) {
println!("{} lentää!", itse.malli);
 }
}

The Lintu ja Lentokone rakenteet toteuttavat Lentää ominaisuus ja tulostaa merkkijonoja Println! makro.

Voit soittaa lentää menetelmää molemmissa rakenteissa tietämättä niiden erityistyyppejä.

fnpää() {
antaa lintu = lintu {
 nimi: merkkijono::from("Kotka"),
 siipien kärkiväli: 2.0,
 };
antaa kone = kone {
 malli: merkkijono::from("Boeing 747"),
 maksiminopeus: 900,
 };


antaa flying_objects: Vecdyn Lennä> = vec![&lintu, &lentokone];
varten esine sisään lentävät_objektit {
 objekti.fly();
 }
}

The pää funktio instantoi Lentokone ja Lintu tyypit. The lentävät_objektit vektori on objektiinstanssien vektori ja varten silmukka kulkee vektorin läpi ja kutsuu lentää tapauksista.

Polymorfismin toteuttaminen ruosteessa

Luokka tai tyyppi on polymorfinen, jos useat tyypit edustavat rajapintaa. Koska piirteet tarjoavat toiminnot käyttäytymisen määrittämiseen Rustissa, samalla kun ne tarjoavat yhteisen käyttöliittymän yleisen koodin kirjoittamiseen, voit käyttää ominaisuuksia polymorfismin toteuttamiseen.

Tässä on ominaisuus nimeltä Piirrettävä joka määrittää käyttäytymisen objektien renderöinnille näytöllä:

piirrePiirrettävä {
fnpiirtää(&itse);
}

Tyypit, jotka toteuttavat Drawable-ominaisuuden, voivat käyttää piirtää toiminto.

structSuorakulmio {
 leveys: u32,
 korkeus: u32,
}
impl Piirrettävä varten Suorakulmio {
fnpiirtää(&itse) {
// Piirrä suorakulmio näytölle
 }
}

Voit kirjoittaa yleistä koodia, joka piirtää objektit, jotka toteuttavat Piirrettävä piirre.

fnpiirrä_objekti(objekti: &T) {
 object.draw();
}

The piirrä_objekti funktiolla on yleinen tyyppi T syötteenä, joka toteuttaa Piirrettävä ominaisuus ja kutsuu piirtää menetelmä ominaisuudessa. Eri esineet voivat toteuttaa Piirrettävä ominaisuus ja pääsy toimintoihin.

Abstractionin toteuttaminen ruosteessa

Abstraktio on OOP-käsite jossa luokat ja rajapinnat ovat käytettävissä määritetyille objekteille ja tyypeille. Voit toteuttaa abstraktiota Rustissa piirteillä.

Tässä on esimerkki mediasoittimen ominaisuuksista:

piirreMedia {
fnpelata(&itse);
}

Rakenteet ja enumit, jotka toteuttavat Media piirteen tulee tarjota toteutus pelata menetelmä.

structSong {
 otsikko: merkkijono,
 taiteilija: merkkijono,
}
impl Media varten Laulu {
fnpelata(&itse) {
println!("Soitetaan kappaletta: {} tekijältä {}", itse.title, itse.taiteilija);
 }
}

The Song struct toteuttaa Media ominaisuus tarjoamalla toteutuksen pelata menetelmä, joka tulostaa viestin kenttien kanssa Song rakenteet konsoliin.

fnpää() {
// Luo kappalerakenteen esiintymä
antaa laulu = laulu {
 otsikko: merkkijono::from("Bohemian Rhapsody"),
 taiteilija: merkkijono::from("Kuningatar"),
 };
// Kutsu toistomenetelmä kappaleinstanssissa
 song.play();
}

The laulu muuttuja on esimerkki Song struct, ja muuttuja voi käyttää ja kutsua pelata menetelmä.

Ruostekoodin järjestäminen on helppoa

Olio-ohjelmointi auttaa koodin organisoinnissa. Rustin moduulijärjestelmän ansiosta voit helposti järjestää Rust-koodisi samalla kun otat OOP-konseptit käyttöön sovelluksessasi, jotta koodisi pysyy järjestyksessä, hallittavissa ja intuitiivisena.