Objektumorientált programozási koncepciók megvalósítása a Go-ban

Az objektum-orientált programozás (OOP) egy olyan programozási paradigma, amely az objektumok központi koncepcióján alapul. Az OOP-ban a kód formázása a funkcionalitás alapján történik, lehetővé téve a kód karbantartását, absztrakciót, újrafelhasználhatóságot, hatékonyságot és számos funkciót az objektumon.

Az objektum attribútumokkal (változókkal) rendelkezik, amelyek meghatározzák annak jellemzőit, tulajdonságait és metódusait (függvényeit), amelyek meghatározzák az objektum műveleteit (eljárásait) és viselkedését.

A Go objektumorientált programozása eltér a többi nyelvtől. Az objektum-orientált koncepciók a Go alkalmazásban struktúrák, interfészek és egyéni típusok használatával valósulnak meg.

Típusok testreszabása a Go-ban

Az egyéni típusok megkönnyítik a hasonló kódok csoportosítását és azonosítását az újrafelhasználáshoz.

Az egyéni típusok deklarálására szolgáló kód a következő:

típus typeName dataType 

Egyéni típus létrehozásakor és változó hozzárendelésekor a típust a segítségével ellenőrizheti tükrözik. Típusú() amely bevesz egy változót és visszaadja a változó típusát.

import("fmt"
 "tükrözni")
típus kettő int// létrehozza a "kettős" típust
var második // "kettő" típusú változó
fmt. Println (tükrözd. TypeOf (szám))

​​​

A szám a változó egy típusa kettő ami egy egész szám. Továbbléphet, ha többet szeretne létrehozni az egyéni típusból.

Struktúrák létrehozása a Go-ban

A struktúrák (struktúrák) a Go objektumorientált programozásának tervrajzai. A struktúrák a mezők felhasználó által meghatározott gyűjteményei.

Egy struktúra sokféle adattípust tartalmazhat, beleértve az összetett típusokat és módszereket.

A következő szintaxissal hozhat létre struktúrát:

típus StructName struct {
// valami kód
}

Hagyományosan a struktúraneveket általában nagybetűvel és nagybetűvel írják az olvashatóság érdekében.

A struktúratípus mezőneveket és adattípusokat vesz fel. A struktúrák bármilyen Go adattípust fogadhatnak, beleértve az egyéni típusokat is.

típus Felhasználó struct {
 mező1 húr
 mező2 int
 tereptérkép térkép[húr]int
}

Példányosíthat egy struktúratípust, ha a struktúrát változóként rendeli hozzá.

példány := Felhasználó{
// valami kód
}

A struct példány feltölthető mezőkkel a példányosításkor az inicializáláskor meghatározott vagy nullára állítható.

példány := Felhasználó{
 mező1: "a húr terület",
 mező2: 10,
 tereptérkép: térkép[húr]int{},
 }

Hozzáférés a szerkezeti elemekhez

A struktúrapéldány mezőit a mező pontjelölésével érheti el.

fmt. Println("Értékmező elérése", példány.mező2)

Ez kiadja a mező2 a példányosított struct példányból.

Módszerek hozzárendelése struktúrákhoz

A függvények (metódusok) hozzárendelése a struktúra típusokhoz úgy történik, hogy megadja a vevő nevét és a struktúra nevét a függvény neve előtt, ahogy az alábbi szintaxisban látható.

func(vevő szerkezetneve)functionName() {
// valami kód
}

A módszer functionName csak a megadott struktúratípuson használható.

Az öröklődés megvalósítása a Go-ban

Az öröklés az az objektumok és típusok azon képessége, hogy hozzáférjenek és használják más objektumok metódusait és attribútumait. A Go nem rendelkezik öröklődés funkcióval, de kompozíciókat használhat. A Go-ban a kompozíció azt jelenti, hogy egy részstruktúrában egy szuperstruktúrára (az örökölendő struktúrára) hivatkozunk azáltal, hogy megadja a szuperstruktúra nevét a részstruktúrának.

A fenti szerkezeti példa segítségével:

típus Felhasználó struct {
 mező1 húr
 mező2 int
 tereptérkép térkép[húr]int
}
típus Felhasználó2 struct {
 Felhasználó
}

Áthaladva a Felhasználó struct nevet a Felhasználó2 struktúra, a Felhasználó2 A struct hozzáférhet az összes metódushoz és attribútumhoz Felhasználó struct a példányosításon, kivéve az absztrakciós technikákat.

fia := User2{
 felhasználó{
 mező1: "baba",
 mező2: 0,
 tereptérkép: nulla,
 },
 }
fmt. Println (son.field2)

A fiú A fenti változó a Felhasználó2 struct. Amint a példában látható, a fiú változó elérheti és példányosíthatja a User típusú értékeket, és használhatja azokat.

Típusmezők beágyazása a Go-ban

A kapszulázás, más néven „információrejtés” a egy objektum metódusainak és attribútumainak egységekre kötésének technikája a használat és a hozzáférés korlátozása, kivéve a meghatározott (olvasási/írási jogosultságokat).

A beágyazás a Go alkalmazásban exportált és nem exportált azonosítók használatával történik a csomagokban.

Exportált azonosítók (olvasás és írás)

Az exportált azonosítók a meghatározott csomagokból és más programokhoz való hozzáférésükből exportálódnak. A mezőazonosító nagybetűs írása a fo mezőt exportálja.

típus Felhasználó struct {
 1. mező húr
 2. mező int
 FieldMap térkép[húr]int
}
típus Felhasználó2 struct {
 Felhasználó
}

Nem exportált azonosítók (csak olvasható)

A nem exportált azonosítók nem kerülnek exportálásra a meghatározott csomagból, és hagyományosan kisbetűsek.

típus Felhasználó struct {
 mező1 húr
 mező2 int
 tereptérkép térkép[húr]int
}
típus Felhasználó2 struct {
 Felhasználó
}

Az exportált és nem exportált azonosítók fogalma egy objektum metódusaira is vonatkozik.

Polimorfizmus a Go-ban

A polimorfizmus egy olyan technika, amellyel a rugalmasság érdekében különböző formákat adnak egy objektumnak.

A Go interfészek segítségével valósítja meg a polimorfizmust. Az interfészek egyéni típusok, amelyeket metódusaláírások meghatározására használnak.

Interfészek deklarálása

Az interfészek deklarálása hasonló a struktúrák deklarálásához. Az interfészek azonban a felület kulcsszó.

típus Interfésznév felület{
//egyes módszerek
}

Az interfész-deklarációk olyan metódusokat tartalmaznak, amelyeket a struct típusok szerint kell megvalósítani.

Interfészek megvalósítása struktúrákban

Az interfészt megvalósító típusokat deklarálni kell, ami után a típus metódusai megvalósítják az interfészt.

// Az interfész
típus Szín felület{
 Festék() húr
}
// A struktúrák deklarálása
típus Zöld struct {
// valamilyen struct specifikus kód
}
típus Kék struct {
// valami konkrét kód
}

A fenti kódrészletben a Szín a-val deklarált interfész Festék által megvalósítandó módszer Zöld és Kék struktúra típusok.

Az interfészek úgy valósulnak meg, hogy metódusokat rendelünk a struktúra típusokhoz, majd a metódust a megvalósítandó interfész metódussal nevezzük el.

func(g zöld)Festék()húr {
Visszatérés "zöldre festve"
}
func(b kék)Festék()húr {
Visszatérés "kékre festve"
}

A Paint módszert zöld és kék típusok valósítják meg, amelyek mostantól meghívhatják és használhatják a Festék módszer.

ecset := zöld{}
fmt. Println (ecset. Festék())

„Zöldre festve” felirat jelenik meg a konzolon, igazolva, hogy az interfész sikeresen implementálásra került.

Absztraháló mezők a Go-ban

Az absztrakció az egy típus lényegtelen metódusainak és attribútumainak elrejtésének folyamata, ami megkönnyíti a program egyes részei védelmét a rendellenes, nem szándékos használat ellen.

A Go nem alkalmazza rögtön az absztrakciót; azonban az absztrakciót interfészek segítségével valósíthatjuk meg.

// az emberek tudnak futni
típus Emberi felület {
 fuss() húr
}
// A fiú lábakkal rendelkező ember
típus Fiú struct {
 Lábak húr
}
// egy fiún lévő metódus megvalósítja a Human interfész run metódusát
func(h fiú)fuss()húr {
Visszatérés h. Lábak
}

A fenti kód létrehozza a Emberi interfész a fuss interfész, amely egy karakterláncot ad vissza. A Fiú típus valósítja meg a fuss módszere a Emberi felületet, és egy karakterláncot ad vissza a példányosításkor.

Az absztrakció megvalósításának egyik módja az, hogy egy struktúrát örökölünk az interfészen, amelynek metódusait absztraháljuk. Sok más megközelítés is létezik, de ez a legegyszerűbb.

típus Személy struct {
 Név húr
 Kor int
 Állapot Ember 
}
funcfő-() {
 személy1 := &Fiú{Lábak: "két láb"}
 személy2 := &Személy{ // személy példája
 Név: "amina",
 Kor: 19,
 Státusz: személy1,
 }
 fmt. Println (személy. Status.run()) 
}

A Személy struktúra örökli a Emberi interfész, és minden metódusához hozzáférhet a változó segítségével Állapot örökli a felületet.

A hivatkozással történő példányosításkor (mutató használatával) a példány példánya Személy struct Személy2 egy példányára hivatkozik a Fiú struct Személy1 és hozzáférést kap a módszerekhez.

Így megadhatja a típus szerint megvalósítandó konkrét metódusokat.

OOP vs funkcionális programozás

Az objektum-orientált programozás fontos paradigma, mivel nagyobb irányítást biztosít a program felett, és ösztönzi a kód újrafelhasználását oly módon, ahogyan a funkcionális programozás nem.

Ez nem teszi a funkcionális programozást rossz választássá, mivel a funkcionális programozás hasznos és jobb lehet bizonyos felhasználási esetekben.

Mi az objektum-orientált programozás? Az alapok laikus kifejezésekkel magyarázva

Olvassa el a következőt

A szerzőről