Rust postrádá nativní podporu pro OOP, ale i tak můžete tyto techniky využít k využití paradigmatu.
Objektově orientované programování (OOP) zjednodušuje návrh softwaru tím, že zdůrazňuje použití objektů k reprezentaci entit a konceptů reálného světa. OOP podporuje udržovatelnost zapouzdřením funkčnosti do objektů.
Rust je flexibilní jazyk, který podporuje funkční a procedurální programování. Ačkoli nativně nepodporuje objektově orientované programování, můžete implementovat koncepty OOP pomocí vestavěných datových typů Rust.
Zapouzdření do rzi
Zapouzdření znamená organizování kódu do samostatných jednotek, které skrývají vnitřní detaily vystavení veřejného rozhraní pro externí interakci s cílem minimalizovat složitost a zlepšit kód udržitelnost.
Rust kód můžete zapouzdřit pomocí modulů. Modul je kolekce položek včetně funkcí, struktur, výčtů a konstant. Moduly Rust poskytují funkce pro seskupování a definování hranic mezi částmi programu.
Použití modulů k zapouzdření dat a funkcí
Modul můžete definovat pomocí mod klíčové slovo následované názvem:
mod můj_modul {
// položky modulu jdou sem
}
Moduly můžete organizovat hierarchicky vnořením jejich deklarací:
mod rodičovský_modul {
mod můj_modul {
// položky modulu jdou sem
}
}
Poté můžete odkazovat na vnořené moduly s úplnou hierarchií, přičemž každý modul oddělíte dvojitou dvojtečkou, například parent_module:: můj_modul.
Ve výchozím nastavení jsou položky v modulech soukromé a přístupné pouze kódu v rámci stejného modulu. Ale můžete moduly zveřejnit pomocí hospoda klíčové slovo:
mod můj_modul {
hospodafnmoje_funkce() {
// sem patří tělo funkce
}
}
Poté můžete přistupovat moje_funkce z jiných částí vašeho programu.
Použití vlastností k definování chování
Dalším způsobem, jak Rust umožňuje zapouzdření, je použití vlastností. Vlastnosti definují chování, které typy mohou implementovat, a zajišťují, že různé typy odpovídají stejnému rozhraní.
hospodavlastnostMožnost tisku {
fntisk(&já);
}hospodastrukturovatMůj typ {
// zde struct pole
}
impl Možnost tisku pro Můj typ {
fntisk(&já) {
// implementace zde
}
}
The Možnost tisku vlastnost má a tisk metoda a Můj typ struct implementuje Možnost tisku vlastnost implementací tisk metoda.
Pomocí vlastností můžete zajistit, že jakýkoli typ, který implementuje Možnost tisku vlastnost má a tisk metoda. To je užitečné při práci s generickým kódem, který potřebuje spolupracovat s různými typy sdílejícími společné chování.
Dědičnost v Rustu
Dědičnost vám umožňuje definovat jednu třídu na základě jiné. Podtřída zdědí vlastnosti a metody svého rodiče.
V Rustu se doporučuje používat kompozici místo dědičnosti. Kompozice je proces vytváření nových objektů kombinací stávajících. Namísto vytváření nové třídy, která dědí funkce ze základní třídy, můžete vytvořit novou strukturu, která obsahuje instanci základní struktury a jejích polí.
Vytváření nových typů kombinací stávajících typů
K vytváření nových typů použijete výčty a struktury. Výčty jsou užitečné pro typy s konečnými hodnotami a struktury mohou obsahovat více polí.
Můžete vytvořit typ výčtu pro různé druhy zvířat.
enumZvíře {
Kočka,
Pes,
Pták,
// ...
}
Případně můžete vytvořit strukturu obsahující pole pro každý typ zvířete. Struktury mohou obsahovat výčty a další typy.
strukturovatZvíře {
název: Tětiva,
stáří: u8,
animal_type: AnimalType,
}
enumTyp zvířete {
Kočka,
Pes,
Pták,
// ...
}
The Zvíře struct obsahuje hodnoty Typ zvířete typ výčtu.
Pomocí vlastností můžete implementovat dědičnost a přidat chování k typu, aniž byste museli vytvářet nový.
vlastnostLétat {
fnlétat(&já);
}
Zde je návod, jak můžete implementovat Létat vlastnost pro více typů.
strukturovatPták {
název: Tětiva,
rozpětí křídel: f32,
}impl Létat pro pták {
fnlétat(&já) {
println!("{} letí!", já.název);
}
}strukturovatLetadlo {
Modelka: Tětiva,
maximální rychlost: u32,
}
impl Létat pro Letadlo {
fnlétat(&já) {
println!("{} letí!", já.Modelka);
}
}
The Pták a Letadlo struktury implementují Létat trait a tisknout řetězce s Println! makro.
Můžete zavolat na létat metoda na obou strukturách bez znalosti jejich konkrétních typů.
fnhlavní() {
nechat pták = pták {
název: Tětiva::z("Orel"),
rozpětí křídel: 2.0,
};nechat rovina = rovina {
Modelka: Tětiva::z("Boeing 747"),
maximální rychlost: 900,
};nechat létající_objekty: Vecdyn Fly> = vec![&pták, &letadlo];
pro objekt v létající_objekty {
object.fly();
}
}
The hlavní funkce vytváří instanci Letadlo a Pták typy. The létající_objekty vector je vektor instancí objektu a pro smyčka prochází vektorem a volá létat metoda na instancích.
Implementace polymorfismu v Rustu
Třída nebo typ je polymorfní, pokud více typů představuje rozhraní. Protože vlastnosti poskytují funkce pro definování chování v Rustu a zároveň poskytují společné rozhraní pro psaní generického kódu, můžete vlastnosti použít k implementaci polymorfismu.
Zde je pojmenována vlastnost Kreslitelný který definuje chování při vykreslování objektů na obrazovce:
vlastnostKreslitelný {
fnkreslit(&já);
}
Typy, které implementují vlastnost Drawable, mají přístup k kreslit funkce.
strukturovatObdélník {
šířka: u32,
výška: u32,
}
impl Kreslitelný pro Obdélník {
fnkreslit(&já) {
// Vykreslení obdélníku na obrazovce
}
}
Můžete napsat obecný kód, který kreslí objekty, které implementují Kreslitelný vlastnost.
fnnakreslit_objekt(objekt: &T) {
objekt.draw();
}
The nakreslit_objekt funkce má obecný typ T jako vstup, který implementuje Kreslitelný vlastnost a nazývá kreslit metoda na vlastnost. Různé objekty mohou implementovat Kreslitelný vlastnost a přístup k funkcím.
Provádění abstrakce v rzi
Abstrakce je koncept OOP kde jsou třídy a rozhraní přístupné zadaným objektům a typům. Abstrakce v Rustu můžete implementovat pomocí vlastností.
Zde je příklad vlastnosti pro přehrávač médií:
vlastnostMédia {
fnhrát si(&já);
}
Struktury a výčty, které implementují Média vlastnost musí poskytovat implementaci pro hrát si metoda.
strukturovatPíseň {
titul: Tětiva,
umělec: Tětiva,
}
impl Média pro píseň {
fnhrát si(&já) {
println!("Přehrává se skladba: {} od {}", já.titul, já.umělec);
}
}
The Píseň struct implementuje Média poskytnutím implementace pro hrát si metoda, která vytiskne zprávu s poli Píseň struktur do konzole.
fnhlavní() {
// Vytvoří instanci struktury Song
nechat song = Song {
titul: Tětiva::z("Bohemian Rhapsody"),
umělec: Tětiva::z("Královna"),
};
// Volání metody play na instanci skladby
song.play();
}
The píseň proměnná je instancí třídy Píseň struct a proměnná může přistupovat a volat hrát si metoda.
Uspořádání kódu Rust je snadné
Objektově orientované programování pomáhá s organizací kódu. Díky modulovému systému Rust můžete snadno organizovat svůj kód Rust a zároveň implementovat koncepty OOP pro vaši aplikaci, aby byl váš kód organizovaný, ovladatelný a intuitivní.