Rust nemá natívnu podporu pre OOP, ale aj tak môžete použiť tieto techniky na využitie paradigmy.
Objektovo orientované programovanie (OOP) zjednodušuje návrh softvéru tým, že kladie dôraz na použitie objektov na reprezentáciu entít a konceptov reálneho sveta. OOP podporuje udržiavateľnosť zapuzdrením funkčnosti do objektov.
Rust je flexibilný jazyk, ktorý podporuje funkčné a procedurálne programovanie. Hoci natívne nepodporuje objektovo orientované programovanie, koncepty OOP môžete implementovať pomocou vstavaných dátových typov Rust.
Zapuzdrenie v hrdze
Zapuzdrenie znamená organizovanie kódu do samostatných jednotiek, ktoré skrývajú vnútorné detaily odhalenie verejného rozhrania pre externú interakciu s cieľom minimalizovať zložitosť a zlepšiť kód udržiavateľnosť.
Rust kód môžete zapuzdriť pomocou modulov. Modul je kolekcia položiek vrátane funkcií, štruktúr, enumov a konštánt. Moduly Rust poskytujú funkcie na zoskupovanie a definovanie hraníc medzi časťami programu.
Použitie modulov na zapuzdrenie údajov a funkcií
Modul môžete definovať pomocou mod kľúčové slovo, za ktorým nasleduje názov:
mod môj_modul {
// položky modulu idú sem
}
Moduly môžete usporiadať hierarchicky vnorením ich vyhlásení:
mod rodičovský_modul {
mod môj_modul {
// položky modulu idú sem
}
}
Potom môžete odkazovať na vnorené moduly s úplnou hierarchiou, pričom každý modul oddelíte dvojitou dvojbodkou, napr. parent_module:: môj_modul.
V predvolenom nastavení sú položky v moduloch súkromné a prístupné iba kódu v rámci toho istého modulu. Moduly však môžete zverejniť pomocou krčma kľúčové slovo:
mod môj_modul {
krčmafnmoja_funkcia() {
// sem patrí telo funkcie
}
}
Potom môžete pristupovať moja_funkcia z iných častí vášho programu.
Použitie vlastností na definovanie správania
Ďalším spôsobom, ako Rust umožňuje zapuzdrenie, je použitie vlastností. Vlastnosti definujú správanie, ktoré môžu typy implementovať, a zabezpečujú, že rôzne typy zodpovedajú rovnakému rozhraniu.
krčmavlastnosťTlačiteľné {
fnvytlačiť(&seba);
}krčmaštrukturovaťMyType {
// tu štrukturujte polia
}
impl Tlačiteľné pre MyType {
fnvytlačiť(&seba) {
// implementácia tu
}
}
The Tlačiteľné vlastnosť má a vytlačiť metóda a MyType struct implementuje Tlačiteľné vlastnosť implementáciou vytlačiť metóda.
Pomocou vlastností môžete zabezpečiť, že každý typ, ktorý implementuje Tlačiteľné vlastnosť má a vytlačiť metóda. To je užitočné pri práci s generickým kódom, ktorý potrebuje spolupracovať s rôznymi typmi zdieľajúcimi spoločné správanie.
Dedičstvo v Rust
Dedičnosť vám umožňuje definovať jednu triedu na základe inej. Podtrieda zdedí vlastnosti a metódy svojho rodiča.
V Ruste sa odporúča použiť kompozíciu namiesto dedenia. Kompozícia je proces vytvárania nových objektov kombináciou existujúcich. Namiesto vytvorenia novej triedy, ktorá zdedí funkčnosť zo základnej triedy, môžete vytvoriť novú štruktúru, ktorá obsahuje inštanciu základnej štruktúry a jej polí.
Vytváranie nových typov kombináciou existujúcich typov
Na vytváranie nových typov použijete enumy a štruktúry. Enumy sú užitočné pre typy s konečnými hodnotami a štruktúry môžu obsahovať viacero polí.
Môžete vytvoriť typ enum pre rôzne druhy zvierat.
enumZviera {
mačka,
Pes,
Vták,
// ...
}
Prípadne môžete vytvoriť štruktúru obsahujúcu polia pre každý typ zvieraťa. Štruktúry môžu obsahovať enumy a iné typy.
štrukturovaťZviera {
názov: Reťazec,
Vek: u8,
animal_type: AnimalType,
}
enumAnimalType {
mačka,
Pes,
Vták,
// ...
}
The Zviera struct obsahuje hodnoty AnimalType typ enumerácie.
Pomocou vlastností môžete implementovať dedičnosť a pridať správanie k typu bez vytvorenia nového.
vlastnosťLietať {
fnlietať(&seba);
}
Tu je návod, ako môžete implementovať Lietať vlastnosť pre viacero typov.
štrukturovaťVták {
názov: Reťazec,
rozpätie krídel: f32,
}impl Lietať pre Vták {
fnlietať(&seba) {
println!("{} letí!", seba.názov);
}
}štrukturovaťLietadlo {
Model: Reťazec,
maximálna rýchlosť: u32,
}
impl Lietať pre rovina {
fnlietať(&seba) {
println!("{} letí!", seba.Model);
}
}
The Vták a Lietadlo štruktúry implementujú Lietať vlastnosti a tlačové reťazce s Println! makro.
Môžete zavolať na lietať na oboch štruktúrach bez toho, aby sme poznali ich špecifické typy.
fnHlavná() {
nech vták = vták {
názov: Reťazec::od("orol"),
rozpätie krídel: 2.0,
};nech rovina = rovina {
Model: Reťazec::od("Boeing 747"),
maximálna rýchlosť: 900,
};nech lietajúce_objekty: Vecdyn Fly> = vec![&vták, &lietadlo];
pre objekt v lietajúce_objekty {
objekt.fly();
}
}
The Hlavná funkcia vytvára inštanciu Lietadlo a Vták typy. The lietajúce_objekty vector je vektor inštancií objektu a pre slučka prechádza cez vektor a volá lietať metóda na príkladoch.
Implementácia polymorfizmu v Rust
Trieda alebo typ je polymorfné, ak viaceré typy predstavujú rozhranie. Keďže vlastnosti poskytujú funkcie na definovanie správania v Ruste a zároveň poskytujú spoločné rozhranie na písanie generického kódu, môžete použiť vlastnosti na implementáciu polymorfizmu.
Tu je pomenovaná vlastnosť Stiahnuteľný ktorý definuje správanie pri vykresľovaní objektov na obrazovke:
vlastnosťStiahnuteľný {
fnkresliť(&seba);
}
Typy, ktoré implementujú vlastnosť Drawable, majú prístup k kresliť funkciu.
štrukturovaťObdĺžnik {
šírka: u32,
výška: u32,
}
impl Stiahnuteľný pre Obdĺžnik {
fnkresliť(&seba) {
// Vykreslenie obdĺžnika na obrazovke
}
}
Môžete napísať generický kód, ktorý kreslí objekty, ktoré implementujú Stiahnuteľný vlastnosť.
fnnakresliť_objekt(objekt: &T) {
objekt.draw();
}
The nakresliť_objekt funkcia má všeobecný typ T ako vstup, ktorý implementuje Stiahnuteľný vlastnosť a nazýva kresliť metóda na vlastnosť. Rôzne objekty môžu implementovať Stiahnuteľný vlastnosti a prístup k funkciám.
Implementácia abstrakcie v hrdze
Abstrakcia je koncept OOP kde sú triedy a rozhrania prístupné pre špecifikované objekty a typy. Abstrakciu v Ruste môžete implementovať pomocou vlastností.
Tu je príklad vlastnosti pre prehrávač médií:
vlastnosťMédiá {
fnhrať(&seba);
}
Štruktúry a zoznamy, ktoré implementujú Médiá vlastnosť musí poskytovať implementáciu pre hrať metóda.
štrukturovaťPieseň {
názov: Reťazec,
umelec: Reťazec,
}
impl Médiá pre Pieseň {
fnhrať(&seba) {
println!("Prehráva sa skladba: {} od {}", seba.názov, seba.umelec);
}
}
The Pieseň struct implementuje Médiá poskytovaním implementácie pre hrať metóda, ktorá vytlačí správu s poľami Pieseň štruktúr do konzoly.
fnHlavná() {
// Vytvorenie inštancie štruktúry Song
nech pieseň = Pieseň {
názov: Reťazec::od("Bohemian Rhapsody"),
umelec: Reťazec::od("kráľovná"),
};
// Volanie metódy prehrávania v inštancii skladby
song.play();
}
The pieseň premenná je inštanciou premennej Pieseň struct a premenná môže pristupovať a volať hrať metóda.
Organizácia Rust Code je jednoduchá
Objektovo orientované programovanie pomáha s organizáciou kódu. Vďaka modulovému systému Rust môžete jednoducho organizovať svoj kód Rust a zároveň implementovať koncepty OOP pre vašu aplikáciu, aby bol váš kód organizovaný, spravovateľný a intuitívny.