1. példa: Golang üres felület
Kezdje az üres felülettel{}, amelyre a Go alkalmazásban interfészként hivatkozunk. Olyan típust jelöl, amely bármilyen értéket képes tárolni. A következő a Go üres felületének forráskódja:
csomag fő-import 'fmt'
típus MarksCalculator felület {}
func fő- () {
volt m MarksCalculator
fmt . Println ( m )
}
Itt azt a kódot adjuk meg, ahol a „MarksCalculator” felület nem rendelkezik meghatározott metódusaláírásokkal, mert üres. Ennek eredményeként nem biztosít semmilyen funkciót. Ezután ennek az üres felületnek a main() függvénye van, ahol egy MarksCalculator típusú „m” változó van deklarálva. Mivel a felület üres, az „m” bármilyen típusú értéket tartalmazhat. Ebben az esetben az „m” nincs inicializálva, így a típusának nulla az értéke, ami „nulla” az interfészek esetében. Ha az „m” értéket az „fmt.Println” használatával nyomtatja ki, akkor „null”-t ad ki a konzolra.
A lekért kimenet „nulla”, ahogy az az előző forráskódtól várható volt:
2. példa: Az interfész Golang implementációja
Ez a rész a Golang felület megvalósítását mutatja be. A típusnak fel kell ajánlania az egyes megadott metódusok megvalósítását egy interfészen, hogy megvalósíthassa azt a Go-ban. A következő a megadott forráskód az interfész megvalósításához:
csomag fő-
import (
'fmt'
)
típus Magánhangzók felület {
SearchVowels () [] rúna
}
típus MyStr húr
func ( st MyStr ) SearchVowels () [] rúna {
volt magánhangzók [] rúna
számára _ , rúna := hatótávolság utca {
ha rúna == 'a' || rúna == 'Ez' || rúna == 'én' || rúna == 'O' || rúna == 'ban ben' {
magánhangzók = mellékel ( magánhangzók , rúna )
}
}
Visszatérés magánhangzók
}
func fő- () {
NewString := MyStr ( 'GoLang interfészek' )
volt v1 Magánhangzók
v1 = NewString
fmt . Printf ( 'A magánhangzók %c' , v1 . SearchVowels ())
}
Itt a kód meghatároz egy „Vowels” nevű interfészt, amely egyetlen SearchVowels() metódust határoz meg, amely a rúna egy szeletét adja vissza (int32 típus). Az interfész lehetővé teszi, hogy bármilyen típusú, ezt a metódusaláírást megvalósító típus hozzárendelhető legyen az interfész típusú változóhoz. Ezután egy új „MyStr” típus deklarálódik, amely az alapul szolgáló típuskarakterlánc álneve. Ez azt jelenti, hogy a „MyStr” örökli a karakterlánc összes metódusát, de egy külön típus.
Ezt követően implementáljuk a SearchVowels() metódust a „MyStr” típushoz. Ez a módszer karakterenként vizsgálja meg a bemeneti karakterláncot, és ellenőrzi, hogy minden karakter magánhangzó-e ('a', 'e', 'i', 'o' vagy 'u'). Ha egy karakter magánhangzó, akkor a magánhangzó szelethez fűződik.
A main() függvényen belül egy „MyStr” típusú „NewString” változó jön létre a „GoLang Interfaces” értékkel. Ezután egy „Vowels” típusú „v1” változót deklarálunk. Mivel a „MyStr” a SearchVowels() metódust valósítja meg, amely a „Vowels” felületen van definiálva, a „NewString” hozzárendelhető a „v1”-hez.
A kimenet megjeleníti a megadott karakterláncban található magánhangzók összes tömbjét:
3. példa: Golang Stringer interfész
Ezenkívül a Golang rendelkezik egy előre meghatározott „Stringer” felülettel az „fmt” csomagban. Lehetővé teszi, hogy egy egyéni típus szabályozza a karakterlánc-ábrázolását, ha a „%v” igével formázzák az „fmt” csomag nyomtatási funkcióiban. A következő példakód a Go stringer felületéhez:
csomag fő-import (
'fmt'
)
típus Diák struct {
Név húr
Fokozat húr
}
func ( s Diák ) Húr () húr {
Visszatérés fmt . Sprintf ( '%s egy(n) %s' , s . Név , s . Fokozat )
}
func fő- () {
s1 := Diák { 'Elena Gilbert' , 'Számítástechnika' }
s2 := Diák { 'Caroline Candice' , 'BBA' }
fmt . Println ( s1 )
fmt . Println ( s2 )
}
Itt a kód először importálja a szükséges csomagot, amely „fmt” a konzolra történő nyomtatáshoz. Ezután meghatározunk egy „Student” típusú struktúrát két mezővel: „Név” és „Fokozat”. Ez a struktúra a tanuló információit reprezentálja. Továbbá létrejön egy String() metódus a „Student” típushoz. Ennek a metódusnak van egy „Student” típusú vevője, és egy karakterláncot ad vissza. A „String()” metódus a Go speciális metódusa, amely egy objektum karakterlánc-ábrázolásának testreszabására szolgál nyomtatáskor. Ebben az esetben a „String()” metódus egy olyan karakterláncot formáz és ad vissza, amely tartalmazza a hallgató nevét és végzettségét.
Ezután van a main() függvény, ahol két változó, az s1 és az s2 „Student” típusú, deklarálva és inicializálva van a hallgatói információkkal. Végül a kód az fmt.Println() függvényt használja az s1 és s2 értékeinek kinyomtatására. Mivel a String() metódus a „Student” típushoz van definiálva, a Go automatikusan meghívja ezt a metódust, amikor kinyomtatja a „Student” objektumot. A String() metódus az „fmt.Sprintf()” függvény segítségével formázza a tanuló adatait, és visszaadja a formázott karakterláncot.
A következő kimenet kiírja a stringer interfész „Student” típusú objektumát:
4. példa: Golang típusú kapcsoló interfész
Ezután jön a Go típusváltó felülete. A típuskapcsoló egy olyan vezérlőstruktúra, amely lehetővé teszi egy interfészérték dinamikus típusának vizsgálatát. Kövesse a típusú switch interfész forráskódját:
csomag fő-import 'fmt
func MyFunction(F1 interfész{}) {
kapcsoló F1.(típus) {
eset int:
fmt.Println(' típus : int , Érték : ', F1.(Ön))
eset karakterlánc:
fmt.Println(' \nTípus : húr , Érték : ', F1.(karakterlánc))
case float64:
fmt.Println(' \nTípus : úszó64 , Érték : ', F1.(float64))
alapértelmezett:
fmt.Println(' \nA típus érvénytelen ')
}
}
func main() {
Saját funkció (' Golang interfészek bemutatója ')
MyFunction (89.7)
Saját funkció (igaz)
}
Itt a megadott kód egy „MyFunction” függvényt határoz meg, amely egy „interface{}” típusú „F1” paramétert vesz fel. Ez azt jelzi, hogy az „F1” bármilyen típusú értéket elfogad. A függvényen belül egy switch utasítást használnak az „F1.(type)”-vel a „MyFunction”-nak átadott érték típusának ellenőrzésére. A „.(type)” szintaxis a típusváltóban használatos az interfészérték mögöttes dinamikus típusának lekérésére. Ne feledje, hogy az itt található kapcsoló esetek három konkrét típust kezelnek: „int”, „string” és „float64”. Ha az „F1” típus megfelel ezen esetek valamelyikének. Kiírja a megfelelő típust és értéket a típusállítások segítségével (F1.(int), F1.(string), F1.(float64)). Ha az „F1” típus nem egyezik a meghatározott esetek egyikével sem, akkor az alapértelmezett eset kerül végrehajtásra, amely a „Típus nem érvényes” szöveget írja ki.
Ezt követően a main() függvényen belül a „MyFunction” háromszor kerül meghívásra különböző értékekkel: egy string, egy float64 és egy Boolean (amit a switch utasítás nem kezel).
A kimenet a kapcsoló interfész bemutatóját jeleníti meg a következő típusú állításokkal:
5. példa: Golang több interfész
Ezenkívül a Go több interfészt kínál, amelyek lehetővé teszik, hogy a kontextustól függően különböző viselkedési készleteket biztosítson. Ezt a szolgáltatást „több interfésznek” vagy „interfész-összetételnek” nevezik. A következő kód a több interfész megvalósítását mutatja be:
csomag fő-import 'fmt'
típus madarak felület {
lélegzik ()
légy ()
}
típus madarak felület {
takarmány ()
}
típus Ahol struct {
kor int
}
func ( d hol ) lélegzik () {
fmt . Println ( 'Galamb lélegzik' )
}
func ( d hol ) légy () {
fmt . Println ( 'galamb repül' )
}
func ( d hol ) takarmány () {
fmt . Println ( 'A galamb nevelje a babákat' )
}
func fő- () {
volt b madarak
d := Ahol {}
b = d
b . lélegzik ()
b . légy ()
volt egy madár
a = d
a . takarmány ()
}
Itt két interfészt határozunk meg: „madarakat” és „madarakat”. A „madarak” felület két módszert deklarál: a breathe() és a fly(). Míg az „avians” felület deklarálja a feed() metódust. Ezután a „galamb” struktúra megvalósítja mind a „madarak”, mind a „madarak” interfész összes metódusát. Ez biztosítja a breathe(), a fly() és a feed() megvalósítását.
Ezután deklaráljuk a „birds” típusú „b” változót a main() függvényen belül. Létrejön egy „galamb” példány, és hozzárendeljük „b”-hez a b = d hozzárendeléssel. Mivel a „dove” a „madarak” felület összes metódusát megvalósítja, ez a hozzárendelés érvényes.
Ezután a breathe() és fly() metódusokat a 'b'-en hívják meg, amely 'birds' típusú. Hasonlóképpen egy „a” típusú „avians” változót deklarálnak és hozzárendelnek a „d dove” példányához. Mivel a „dove” az „avians” felületen definiált feed() metódust valósítja meg, ez a hozzárendelés is érvényes. A feed() metódus az „a”-n van meghívva, amely „avians” típusú. Mivel az „a” a „dove” példányt tartalmazza, a „dove” által megvalósított feed() metódus végrehajtásra kerül.
A kimenet azt mutatja, hogy az interfészek metódusai megfelelően vannak végrehajtva:
Következtetés
Megismertük a Go felületek alapjait, és gyakorlati példákkal illusztráltuk a használatukat. Interfészek definiálásával és különböző típusokkal való megvalósításával rugalmas és bővíthető programokat készíthetünk.