Kuidas Rustis objektorienteeritud programmeerimise kontseptsioone rakendada

Objektorienteeritud programmeerimine (OOP) lihtsustab tarkvara kujundamist, rõhutades objektide kasutamist reaalse maailma olemite ja kontseptsioonide esindamiseks. OOP soodustab hooldatavust, kapseldades funktsioonid objektidesse.

Rust on paindlik keel, mis toetab funktsionaalset ja protseduurilist programmeerimist. Kuigi see ei toeta algselt objektorienteeritud programmeerimist, saate OOP-kontseptsioone rakendada, kasutades Rusti sisseehitatud andmetüüpe.

Kapseldamine roostesse

Kapseldamine hõlmab koodi organiseerimist iseseisvateks üksusteks, mis peidavad samal ajal sisemisi üksikasju avaliku liidese paljastamine välise suhtluse jaoks, et minimeerida keerukust ja parandada koodi hooldatavus.

Rooste koodi saate kapseldada moodulitega. Moodul on üksuste kogum, mis sisaldab funktsioone, struktuure, loendeid ja konstante. Roostemoodulid pakuvad funktsioone programmi osade rühmitamiseks ja piiride määratlemiseks.

Moodulite kasutamine andmete ja funktsioonide kapseldamiseks

Mooduli saate määratleda kasutades mod märksõna, millele järgneb nimi:

mod minu_moodul {
// mooduli üksused lähevad siia
}

Saate mooduleid hierarhiliselt korraldada, pesastades nende deklaratsioonid:

mod vanemate_moodul {
mod minu_moodul {
// mooduli üksused lähevad siia
 }
}

Seejärel saate viidata täieliku hierarhiaga pesastatud moodulitele, eraldades iga mooduli näiteks topeltkooloniga. vanem_moodul:: minu_moodul.

Vaikimisi on moodulites olevad üksused privaatsed ja neile pääseb juurde ainult sama mooduli koodile. Kuid saate mooduleid avalikustada kasutades pubi märksõna:

mod minu_moodul {
pubifnminu_funktsioon() {
// funktsiooni keha läheb siia
 }
}

Seejärel pääsete juurde minu_funktsioon teie programmi muudest osadest.

Tunnuste kasutamine käitumise määratlemiseks

Teine viis, kuidas Rust kapseldamist võimaldab, on tunnuste kasutamine. Tunnused määratlevad käitumise, mida tüübid saavad rakendada, ja tagavad, et erinevad tüübid vastavad samale liidesele.

pubiomadusPrinditav {
fnprintida(&ise);
}
pubistruktuurMyType {
// struktureerige siia väljad
}
impl Prinditav jaoks Minu tüüp {
fnprintida(&ise) {
// rakendamine siin
 }
}

The Prinditav omadusel on a printida meetod ja MyType struct rakendab Prinditav tunnust rakendades printida meetod.

Tunnuste abil saate tagada, et mis tahes tüüpi, mis rakendab Prinditav omadusel on a printida meetod. See on mugav, kui töötate üldise koodiga, mis peab töötama koos erinevate tüüpidega, millel on ühine käitumine.

Pärand roostes

Pärimine võimaldab teil määratleda ühe klassi erineva klassi alusel. Alamklass pärib oma vanema omadused ja meetodid.

Roostes julgustatakse teid kasutama pärimise asemel kompositsiooni. Kompositsioon on protsess, mille käigus luuakse uusi objekte olemasolevate kombineerimise teel. Selle asemel, et luua uus klass, mis pärib põhiklassi funktsionaalsuse, saate luua uue struktuuri, mis sisaldab põhistruktuuri eksemplari ja selle välju.

Uute tüüpide loomine olemasolevate tüüpide kombineerimise teel

Uute tüüpide loomiseks kasutate loendeid ja struktuure. Enumid on mugavad piiratud väärtustega tüüpide jaoks ja struktuurid võivad sisaldada mitut välja.

Saate luua eri tüüpi loomade jaoks enum-tüübi.

enumLoom {
 kass,
 koer,
 Lind,
// ...
}

Teise võimalusena saate luua struktuuri, mis sisaldab välju iga loomatüübi jaoks. Konstruktsioonid võivad sisaldada enumi ja muud tüüpi.

struktuurLoom {
 nimi: String,
 vanus: u8,
 animal_type: loomatüüp,
}
enumLoomatüüp {
 kass,
 koer,
 Lind,
// ...
}

The Loom struct sisaldab väärtusi Loomatüüp loenduse tüüp.

Tunnuste abil saate rakendada pärimist ja lisada tüübile käitumist ilma uut loomata.

omadusLennata {
fnlennata(&ise);
}

Siin on, kuidas saate rakendada Lennata omadus mitme tüübi jaoks.

struktuurLind {
 nimi: String,
 tiibade siruulatus: f32,
}
impl Lennata jaoks Lind {
fnlennata(&ise) {
println!("{} lendab!", ise.nimi);
 }
}
struktuurLennuk {
 mudel: String,
 maksimum kiirus: u32,
}
impl Lennata jaoks Lennuk {
fnlennata(&ise) {
println!("{} lendab!", ise.mudel);
 }
}

The Lind ja Lennuk struktuurid rakendavad Lennata tunnus- ja trükistringid Println! makro.

Võite helistada lennata meetodit mõlemal struktuuril, teadmata nende konkreetseid tüüpe.

fnpeamine() {
lase lind = lind {
 nimi: String::from("Kotkas"),
 tiibade siruulatus: 2.0,
 };
lase lennuk = lennuk {
 mudel: String::from("Boeing 747"),
 maksimum kiirus: 900,
 };
lase lendavad_objektid: Vecdyn Lenda> = vec![&lind, &lennuk];
jaoks objektiks sisse lendavad_objektid {
 objekt.fly();
 }
}

The peamine funktsioon instantseerib Lennuk ja Lind tüübid. The lendavad_objektid vektor on objekti eksemplaride vektor ja jaoks silmus läbib vektori ja kutsub esile lennata meetodit juhtumitel.

Polümorfismi rakendamine roostes

Klass või tüüp on polümorfne, kui liidest esindavad mitu tüüpi. Kuna tunnused pakuvad funktsiooni Rustis käitumise määratlemiseks, pakkudes samal ajal ühist liidest üldise koodi kirjutamiseks, saate tunnuseid kasutada polümorfismi rakendamiseks.

Siin on omadus nimega Joonistatav mis määrab ekraanil objektide renderdamise käitumise:

omadusJoonistatav {
fnjoonistada(&ise);
}

Tüübid, mis rakendavad tunnust Joonistatav, pääsevad juurde joonistada funktsiooni.

struktuurRistkülik {
 laius: u32,
 kõrgus: u32,
}
impl Joonistatav jaoks Ristkülik {
fnjoonistada(&ise) {
// Ristküliku renderdamine ekraanil
 }
}

Saate kirjutada üldise koodi, mis joonistab objektid, mis rakendavad Joonistatav omadus.

fnjoonista_objekt(objekt: &T) {
 objekt.draw();
}

The joonista_objekt funktsioon võtab üldist tüüpi T sisendiks, mis rakendab Joonistatav omadus ja kutsub üles joonistada meetod tunnuse kohta. Erinevaid objekte saab rakendada Joonistatav omadus ja juurdepääs funktsioonidele.

Abstraktsiooni rakendamine roostes

Abstraktsioon on OOP kontseptsioon kus klassid ja liidesed on juurdepääsetavad määratud objektidele ja tüüpidele. Abstraktsiooni saab Rustis rakendada tunnustega.

Siin on näide meediumipleieri omadusest:

omadusMeedia {
fnmängida(&ise);
}

Struktuurid ja enumid, mis rakendavad Meedia tunnus peab pakkuma teostuse mängida meetod.

struktuurLaul {
 pealkiri: String,
 kunstnik: String,
}
impl Meedia jaoks Laul {
fnmängida(&ise) {
println!("Lugu esitamine: {}, autor {}", ise.title, ise.kunstnik);
 }
}

The Laul struct rakendab Meedia omadus, pakkudes teostust mängida meetod, mis prindib väljadega sõnumi Laul konstruktsioonid konsooli.

fnpeamine() {
// Loo struktuuri Song eksemplar
lase laul = laul {
 pealkiri: String::from("Bohemian Rhapsody"),
 kunstnik: String::from("kuninganna"),
 };
// Esitusmeetodi kutsumine loo eksemplaril
 song.play();
}

The laul muutuja on eksemplar Laul struct ja muutuja pääseb juurde ja helistab sellele mängida meetod.

Roostekoodi korraldamine on lihtne

Objektorienteeritud programmeerimine aitab koodi organiseerimisel. Tänu Rusti moodulsüsteemile saate hõlpsalt oma Rusti koodi korraldada, rakendades samal ajal oma rakenduses OOP-kontseptsioone, et hoida oma kood korrastatuna, hallatavana ja intuitiivsena.