Objektum-orientált programozási koncepciók implementálása a Rustban

Az objektum-orientált programozás (OOP) leegyszerűsíti a szoftvertervezést azáltal, hogy hangsúlyozza az objektumok használatát a valós entitások és fogalmak ábrázolására. Az OOP elősegíti a karbantarthatóságot azáltal, hogy a funkciókat objektumokba zárja be.

A Rust egy rugalmas nyelv, amely támogatja a funkcionális és eljárási programozást. Bár natívan nem támogatja az objektum-orientált programozást, megvalósíthatja az OOP koncepciókat a Rust beépített adattípusainak használatával.

Tokozás rozsdába

A beágyazás azt jelenti, hogy a kódot önálló egységekre kell rendezni, amelyek elrejtik a belső részleteket nyilvános interfész biztosítása a külső interakció számára a bonyolultság minimalizálása és a kód javítása érdekében karbantarthatóság.

A Rust kódot modulokkal is beágyazhatja. A modul elemek gyűjteménye, beleértve a függvényeket, struktúrákat, enumokat és konstansokat. A Rust modulok funkcionalitást biztosítanak a program részei közötti csoportosításhoz és határok meghatározásához.

Modulok használata adatok és funkciók beágyazására

A modul segítségével definiálhat mod kulcsszó után egy név:

mod my_module {
// a modulelemek ide kerülnek
}

A modulokat hierarchikusan rendezheti deklarációik egymásba ágyazásával:

mod szülő_modul {
mod my_module {
// a modulelemek ide kerülnek
 }
}

Ezután hivatkozhat a beágyazott modulokra a teljes hierarchiával, az egyes modulokat kettős kettősponttal elválasztva, például, szülő_modul:: saját_modul.

Alapértelmezés szerint a modulokon belüli elemek privátak, és csak az ugyanazon a modulon belüli kód számára érhetők el. De a modulokat nyilvánossá teheti a kocsma kulcsszó:

mod my_module {
kocsmafnmy_function() {
// függvénytest megy ide
 }
}

Ezután hozzáférhet my_function programod más részeiből.

Jellemzők használata viselkedések meghatározására

Egy másik módja annak, hogy a Rust lehetővé teszi a tokozást, a tulajdonságok használata. A tulajdonságok olyan viselkedéseket határoznak meg, amelyeket a típusok megvalósíthatnak, és biztosítják, hogy a különböző típusok ugyanahhoz a felülethez illeszkedjenek.

kocsmajellemvonásNyomtatható {
fnnyomtatás(&maga);
}
kocsmastructMyType {
// struct mezőket ide
}
impl Nyomtatható számára MyType {
fnnyomtatás(&maga) {
// megvalósítás itt
 }
}

A Nyomtatható tulajdonsága van a nyomtatás módszer, és a MyType struct valósítja meg a Nyomtatható vonás megvalósításával a nyomtatás módszer.

A tulajdonságok használatával biztosíthatja, hogy bármely típus, amely megvalósítja a Nyomtatható tulajdonsága van a nyomtatás módszer. Ez akkor hasznos, ha olyan általános kóddal dolgozik, amelynek együtt kell működnie a különböző típusokkal, amelyek közös viselkedést mutatnak.

Öröklés Rozsdában

Az öröklődés lehetővé teszi egy osztály meghatározását egy másik osztály alapján. Az alosztály örökli a szülő tulajdonságait és metódusait.

A Rust-ban arra ösztönzik, hogy öröklés helyett kompozíciót használjon. A kompozíció új objektumok létrehozásának folyamata a meglévők kombinálásával. Ahelyett, hogy új osztályt hozna létre, amely az alaposztály funkcionalitását örökli, létrehozhat egy új struktúrát, amely tartalmazza az alapstruktúra egy példányát és annak mezőit.

Új típusok létrehozása a meglévő típusok kombinálásával

Új típusok létrehozásához enumokat és struktúrákat fog használni. Az enumok hasznosak a véges értékű típusok számára, és a struktúrák több mezőt is tartalmazhatnak.

Létrehozhat egy enum típust különböző típusú állatokhoz.

enumÁllat {
 Macska,
 Kutya,
 Madár,
// ...
}

Alternatív megoldásként létrehozhat egy struktúrát, amely minden állattípushoz mezőket tartalmaz. A szerkezetek enumokat és más típusokat tartalmazhatnak.

structÁllat {
 név: Húr,
 kor: u8,
 animal_type: AnimalType,
}
enumAnimalType {
 Macska,
 Kutya,
 Madár,
// ...
}

A Állat struct értékeit tartalmazza AnimalType felsorolás típusa.

Használhatja a tulajdonságokat az öröklődés megvalósítására és viselkedés hozzáadására egy típushoz anélkül, hogy újat hozna létre.

jellemvonásLégy {
fnlégy(&maga);
}

Így valósíthatja meg a Légy tulajdonság több típushoz.

structMadár {
 név: Húr,
 szárnyfesztávolság: f32,
}
impl Légy számára madár {
fnlégy(&maga) {
println!("{} repül!", maga.név);
 }
}
structRepülőgép {
 modell: Húr,
 teljes sebesség: u32,
}
impl Légy számára Repülőgép {
fnlégy(&maga) {
println!("{} repül!", maga.modell);
 }
}

A Madár és Repülőgép struktúrák valósítják meg a Légy vonás és nyomtatási karakterláncok a Println! makró.

Felhívhatja a légy módszert mindkét struktúrán anélkül, hogy ismernénk a konkrét típusukat.

fnfő-() {
hagyja madár = madár {
 név: Húr::tól től("Sas"),
 szárnyfesztávolság: 2.0,
 };
hagyja sík = sík {
 modell: Húr::tól től("Boeing 747"),
 teljes sebesség: 900,
 };
hagyja flying_objects: Vecdyn Fly> = vec![&madár, &repülő];
számára tárgy ban ben repülő_objektumok {
 object.fly();
 }
}

A fő- függvény példányosítja a Repülőgép és Madár típusok. A repülő_tárgyak vektor az objektumpéldányok vektora, és a számára hurok áthalad a vektoron, és meghívja a légy módszert a példányokon.

A polimorfizmus megvalósítása rozsdában

Egy osztály vagy típus az polimorf, ha több típus képvisel egy interfészt. Mivel a tulajdonságok biztosítják a funkcionalitást a Rust viselkedésének meghatározásához, miközben közös felületet biztosítanak az általános kód írásához, a Jellemzők segítségével megvalósíthatja a polimorfizmust.

Itt van egy elnevezett tulajdonság Rajzolható amely meghatározza az objektumok képernyőn való megjelenítésének viselkedését:

jellemvonásRajzolható {
fnhúz(&maga);
}

A Rajzolható tulajdonságot megvalósító típusok hozzáférhetnek a húz funkció.

structTéglalap {
 szélesség: u32,
 magasság: u32,
}
impl Rajzolható számára Téglalap {
fnhúz(&maga) {
// A téglalap megjelenítése a képernyőn
 }
}

Írhat általános kódot, amely olyan objektumokat rajzol, amelyek megvalósítják a Rajzolható jellemvonás.

fnrajzol_objektum(objektum: &T) {
 object.draw();
}

A rajzol_objektum függvény általános típust vesz fel T bemenetként, amely megvalósítja a Rajzolható vonás és hívja a húz módszer a tulajdonságon. Különböző objektumok hajthatják végre a Rajzolható tulajdonságot, és hozzáférhet a funkciókhoz.

Absztrakció megvalósítása rozsdában

Az absztrakció az OOP fogalom ahol az osztályok és interfészek elérhetők meghatározott objektumok és típusok számára. Rusztban az absztrakciót tulajdonságokkal valósíthatja meg.

Íme egy példa a médialejátszó jellemzőire:

jellemvonásMédia {
fnjáték(&maga);
}

Struktúrák és enumok, amelyek megvalósítják a Média A tulajdonságnak megvalósítást kell biztosítania a játék módszer.

structDal {
 cím: Húr,
 művész: Húr,
}
impl Média számára Dal {
fnjáték(&maga) {
println!("Dal lejátszása: {}, szerző: {}", maga.cím, maga.művész);
 }
}

A Dal struct valósítja meg a Média vonás megvalósítását biztosítva a játék metódus, amely üzenetet nyomtat a mezőivel Dal struktúrákat a konzolhoz.

fnfő-() {
// Hozzon létre egy példányt a Song struktúrából
hagyja dal = Song {
 cím: Húr::tól től("Bohém Rapszódia"),
 művész: Húr::tól től("Királynő"),
 };
// Hívja meg a lejátszási metódust a dalpéldányon
 dal.play();
}

A dal változó a Dal struct, és a változó elérheti és meghívhatja a játék módszer.

A Rust Code rendszerezése egyszerű

Az objektum-orientált programozás segít a kódszervezésben. A Rust modulrendszerének köszönhetően könnyedén rendszerezheti Rust kódját, miközben megvalósítja az OOP-koncepciókat az alkalmazásban, hogy a kód rendszerezett, kezelhető és intuitív maradjon.