Příklady rozhraní Golang

Priklady Rozhrani Golang



V Go obsahuje sada podpisů metod rozhraní. Určuje skupinu akcí, které musí typ provést, aby bylo určeno, že splňuje dané rozhraní. Jinými slovy, rozhraní specifikuje metody, které typ musí mít, ale neposkytuje informace o implementaci. Ačkoli rozhraní Go poskytují výkonný mechanismus pro dosažení polymorfního chování a psaní opakovaně použitelného kódu. V tomto příspěvku prozkoumáme myšlenku rozhraní v Go a nabídneme příklady ze skutečného světa, abychom ukázali, jak je používat.

Příklad 1: Prázdné rozhraní Golang

Začněte s prázdným rozhraním{}, které se v Go označuje jako rozhraní. Označuje typ, který může uložit jakýkoli druh hodnoty. Níže je uveden zdrojový kód pro prázdné rozhraní v Go:

balík hlavní
import 'fmt'
typ MarksCalculator rozhraní {}
func hlavní () {
byl m Kalkulačka známek
fmt . Println ( m )
}

Zde poskytujeme kód, kde rozhraní „MarksCalculator“ nemá žádné specifikované podpisy metod, protože je prázdné. V důsledku toho neposkytuje žádné funkce. Dále máme funkci main() tohoto prázdného rozhraní, kde je deklarována proměnná „m“ typu MarksCalculator. Protože je rozhraní prázdné, „m“ může obsahovat jakoukoli hodnotu jakéhokoli typu. V tomto případě je „m“ neinicializované, takže má pro svůj typ nulovou hodnotu, která je „nulová“ pro rozhraní. Když je „m“ vytištěno pomocí „fmt.Println“, vypíše do konzole „nula“.







Výstup, který je načten, je „nulový“, jak se očekávalo z předchozího zdrojového kódu:





Příklad 2:  Implementace rozhraní Golang

Tato část ukazuje implementaci rozhraní Golang. Typ musí nabízet implementaci pro každou ze zadaných metod v rozhraní, aby ji mohl implementovat v Go. Níže je uveden zdrojový kód pro implementaci rozhraní:





balík hlavní
import (
'fmt'
)
typ Samohlásky rozhraní {
HledatShlásky () [] runa
}
typ MyStr tětiva
func ( st MyStr ) HledatShlásky () [] runa {
byl samohlásky [] runa
pro _ , runa := rozsah Svatý {
-li runa == 'A' || runa == 'To je' || runa == 'já' || runa == 'Ó' || runa == 'v' {
samohlásky = připojit ( samohlásky , runa )
}
}
vrátit se samohlásky
}

func hlavní () {
Nový řetězec := MyStr ( 'Rozhraní GoLang' )
byl v1 Samohlásky
v1 = Nový řetězec
fmt . Printf ( 'Samohlásky jsou %c' , v1 . HledatShlásky ())
}

Zde kód definuje rozhraní nazvané „Vowels“, které specifikuje jedinou metodu SearchVowels(), která vrací část runy (typ int32). Rozhraní umožňuje libovolnému typu, který implementuje tento podpis metody, přiřadit proměnné typu rozhraní. Poté je deklarován nový typ „MyStr“, což je alias pro základní řetězec typu. To znamená, že „MyStr“ dědí všechny metody řetězce, ale jedná se o odlišný typ.

Poté implementujeme metodu SearchVowels() pro typ „MyStr“. Tato metoda prohledává vstupní řetězec znak po znaku a kontroluje, zda je každý znak samohláskou („a“, „e“, „i“, „o“ nebo „u“). Pokud je znakem samohláska, je připojena k řezu samohlásky.



Uvnitř funkce main() je vytvořena proměnná „NewString“ typu „MyStr“ s hodnotou „GoLang Interfaces“. Dále je deklarována proměnná „v1“ typu „Samohlásky“. Protože „MyStr“ implementuje metodu SearchVowels(), která je definována v rozhraní „Vowels“, lze „NewString“ přiřadit „v1“.

Výstup zobrazí všechna pole samohlásek, které se nacházejí v zadaném řetězci:

Příklad 3: Rozhraní Golang Stringer

Golang má navíc předdefinované rozhraní „Stringer“ v balíčku „fmt“. Umožňuje vlastnímu typu řídit reprezentaci řetězce při formátování pomocí slovesa „%v“ v tiskových funkcích balíčku „fmt“. Níže je uveden příklad kódu pro stringer rozhraní Go:

balík hlavní
import (
'fmt'
)
typ Student strukturovat {
název tětiva
Stupeň tětiva
}
func ( s Student ) Tětiva () tětiva {
vrátit se fmt . Sprintf ( '%s je (n) %s' , s . název , s . Stupeň )
}
func hlavní () {
s1 := Student { 'Elena Gilbert' , 'Počítačová věda' }
s2 := Student { 'Caroline Candice' , 'BBA' }
fmt . Println ( s1 )
fmt . Println ( s2 )
}

Zde kód nejprve importuje potřebný balíček, který je „fmt“ pro tisk do konzole. Poté definujeme strukturu typu „Student“ se dvěma poli: „Jméno“ a „Stupeň“. Tato struktura představuje informace o studentovi. Dále je vytvořena metoda String() pro typ „Student“. Tato metoda má přijímač typu „Student“ a vrací řetězec. Metoda „String()“ je speciální metoda v Go, která se používá k přizpůsobení řetězcové reprezentace objektu při jeho tisku. V tomto případě metoda „String()“ zformátuje a vrátí řetězec, který obsahuje jméno a titul studenta.

Dále máme funkci main(), kde jsou dvě proměnné, s1 a s2 typu „Student“, deklarovány a inicializovány informacemi o studentech. Nakonec kód používá funkci fmt.Println() k tisku hodnot s1 a s2. Protože metoda String() je definována pro typ „Student“, Go automaticky volá tuto metodu při tisku objektu „Student“. Metoda String() formátuje studentovy informace pomocí funkce „fmt.Sprintf()“ a vrací naformátovaný řetězec.

Následující výstup vytiskne objekt typu „Student“ rozhraní stringer:

Příklad 4: Rozhraní přepínače typu Golang

Pak přichází rozhraní pro přepínání typů Go. Přepínač typu je řídicí struktura, která nám umožňuje kontrolovat dynamický typ hodnoty rozhraní. Postupujte podle zdrojového kódu rozhraní přepínače typů:

balík hlavní
import 'fmt
func MyFunction(rozhraní F1{}) {
přepínač F1. (typ) {
case int:
fmt.Println('
Typ : int , Hodnota : ', F1. (vy))
řetězec případu:
fmt.Println('
\nZadejte : tětiva , Hodnota : ', F1.(řetězec))
pouzdro float64:
fmt.Println('
\nZadejte : plovák64 , Hodnota : ', F1.(float64))
výchozí:
fmt.Println('
\nTyp není platný ')
}
}
func main() {
MojeFunkce('
Výukový program rozhraní Golang ')
MyFunction (89,7)
MyFunction (pravda)
}

Zde poskytnutý kód definuje funkci „MyFunction“, která přebírá parametr „F1“ typu „rozhraní{}“. To znamená, že „F1“ může přijmout hodnotu jakéhokoli typu. Uvnitř funkce se používá příkaz switch s „F1.(type)“ ke kontrole typu hodnoty, která je předána „MyFunction“. Syntaxe „.(type)“ se používá v přepínači typu k získání základního dynamického typu hodnoty rozhraní. Všimněte si, že případy přepínačů zde zpracovávají tři specifické typy: „int“, „string“ a „float64“. Pokud typ „F1“ odpovídá jednomu z těchto případů. Vypíše odpovídající typ a hodnotu pomocí typových výrazů (F1.(int), F1.(řetězec), F1.(float64)). Pokud typ „F1“ neodpovídá žádnému z definovaných případů, provede se výchozí případ, který vypíše „Typ není platný“.

Poté se v rámci funkce main() zavolá „MyFunction“ třikrát s různými hodnotami: řetězec, float64 a logická hodnota (která není zpracována v příkazu switch).

Výstup zobrazuje demonstraci rozhraní přepínače s typovými tvrzeními:

Příklad 5: Vícenásobná rozhraní Golang

Go navíc nabízí několik rozhraní, která mu umožňují poskytovat různé sady chování v závislosti na kontextu. Tato funkce se nazývá „více rozhraní“ nebo „složení rozhraní“. Následující kód ukazuje implementaci více rozhraní:

balík hlavní
import 'fmt'
typ ptactvo rozhraní {
dýchat ()
létat ()
}

typ létavci rozhraní {
krmit ()
}
typ Kde strukturovat {
stáří int
}
func ( d kde ) dýchat () {
fmt . Println ( 'Holubice dýchá' )
}
func ( d kde ) létat () {
fmt . Println ( 'holubičí moucha' )
}
func ( d kde ) krmit () {
fmt . Println ( 'Holubice vychovává miminka' )
}
func hlavní () {
byl b ptáci
d := Kde {}
b = d
b . dýchat ()
b . létat ()
byl létavci
A = d
A . krmit ()
}

Zde definujeme dvě rozhraní: „ptáci“ a „ptáci“. Rozhraní „birds“ deklaruje dvě metody: breathe() a fly(). Zatímco rozhraní „avians“ deklaruje metodu feed(). Poté struktura „holubice“ implementuje všechny metody rozhraní „ptáci“ i „ptáci“. Poskytuje implementace pro breathe(), fly() a feed().

Dále deklarujeme proměnnou „b“ typu „birds“ ve funkci main(). Vytvoří se instance „holubice“ a přiřadí se „b“ pomocí přiřazení b = d. Protože „holubice“ implementuje všechny metody rozhraní „ptáci“, je toto přiřazení platné.

Poté jsou metody breathe() a fly() volány na „b“, které je typu „birds“. Podobně je deklarována proměnná „a“ typu „avians“ a přiřazena k instanci „holubice“ „d“. Protože „dove“ implementuje metodu feed(), která je definována v rozhraní „avians“, je toto přiřazení také platné. Metoda feed() se volá na „a“, což je typ „avians“. Protože „a“ obsahuje instanci „holubice“, provede se metoda feed() implementovaná „holubicí“.

Výstup ukazuje, že metody rozhraní jsou prováděny správně:

Závěr

Naučili jsme se základy rozhraní Go a poskytli jsme praktické příklady, které ilustrují jejich použití. Definováním rozhraní a jejich implementací různými typy můžeme vytvářet flexibilní a rozšiřitelné programy.