Eksempel 1: Golang Empty Interface
Begynd med den tomme grænseflade{}, som omtales som grænsefladen i Go. Det angiver en type, der kan lagre enhver form for værdi. Følgende er kildekoden til den tomme grænseflade i Go:
pakke vigtigsteimportere 'fmt'
type Marks Calculator interface {}
func vigtigste () {
var m Marks Lommeregner
fmt . Udskrivln ( m )
}
Her giver vi koden, hvor 'MarksCalculator'-grænsefladen ikke har nogen specificerede metodesignaturer, fordi den er tom. Som et resultat giver det ingen funktionalitet. Dernæst har vi main()-funktionen af denne tomme grænseflade, hvor en variabel 'm' af typen MarksCalculator er erklæret. Da grænsefladen er tom, kan 'm' indeholde enhver værdi af enhver type. I dette tilfælde er 'm' uinitialiseret, så den har en nulværdi for sin type, som er 'nul' for grænseflader. Når 'm' udskrives med 'fmt.Println', udsender det 'nul' til konsollen.
Det output, der hentes, er 'nul' som forventet fra den tidligere kildekode:
Eksempel 2: Golang-implementering af grænseflade
Dette afsnit demonstrerer implementeringen af Golang-grænsefladen. En type skal tilbyde implementeringen for hver af de specificerede metoder i en grænseflade for at implementere den i Go. Følgende er givet kildekoden til grænsefladeimplementeringen:
pakke vigtigste
importere (
'fmt'
)
type Vokaler interface {
Søg efter vokaler () [] rune
}
type MyStr snor
func ( st MyStr ) Søg efter vokaler () [] rune {
var vokaler [] rune
til _ , rune := rækkevidde st {
hvis rune == 'en' || rune == 'Det er' || rune == 'jeg' || rune == 'O' || rune == 'i' {
vokaler = Tilføj ( vokaler , rune )
}
}
Vend tilbage vokaler
}
func vigtigste () {
NewString := MyStr ( 'GoLang-grænseflader' )
var v1 Vokaler
v1 = NewString
fmt . Printf ( 'Vokaler er %c' , v1 . Søg efter vokaler ())
}
Her definerer koden en grænseflade ved navn 'Vokelser', som specificerer en enkelt metode SearchVowels(), der returnerer et udsnit af runen (type int32). En grænseflade gør det muligt at tildele enhver type, der implementerer denne metodesignatur, til en variabel af grænsefladetypen. Derefter erklæres en ny 'MyStr'-type, som er et alias for den underliggende typestreng. Dette betyder, at 'MyStr' arver alle strengmetoderne, men er en særskilt type.
Derefter implementerer vi SearchVwels()-metoden for typen 'MyStr'. Denne metode scanner inputstrengen tegn for tegn og kontrollerer, om hvert tegn er en vokal ('a', 'e', 'i', 'o' eller 'u'). Hvis et tegn er en vokal, tilføjes det til vokalskiven.
Inde i main()-funktionen oprettes en 'NewString'-variabel af 'MyStr'-typen med værdien 'GoLang Interfaces'. Dernæst erklæres en 'v1'-variabel af typen 'Vokaler'. Da 'MyStr' implementerer SearchVwels()-metoden, der er defineret i 'Vwels'-grænsefladen, kan 'NewString' tildeles til 'v1'.
Outputtet viser alle de vokaler, der findes i den angivne streng:
Eksempel 3: Golang Stringer Interface
Derudover har Golang den foruddefinerede 'Stringer'-grænseflade i 'fmt'-pakken. Det tillader en brugerdefineret type at styre sin strengrepræsentation, når den er formateret med '%v' verbet i 'fmt'-pakkens udskrivningsfunktioner. Følgende er eksempelkoden for Stringer-grænsefladen til Go:
pakke vigtigsteimportere (
'fmt'
)
type Studerende struktur {
Navn snor
Grad snor
}
func ( s Student ) Snor () snor {
Vend tilbage fmt . Sprintf ( '%s er en (n) %s' , s . Navn , s . Grad )
}
func vigtigste () {
s1 := Studerende { 'Elena Gilbert' , 'Computer videnskab' }
s2 := Studerende { 'Caroline Candice' , 'BBA' }
fmt . Udskrivln ( s1 )
fmt . Println ( s2 )
}
Her importerer koden først den nødvendige pakke, som er 'fmt' til at udskrive til konsollen. Derefter definerer vi en strukturtype 'Student' med to felter: 'Navn' og 'Grad'. Denne struktur repræsenterer en elevs information. Yderligere oprettes en String()-metode for 'Student'-typen. Denne metode har en modtager af typen 'Student' og returnerer en streng. Metoden 'String()' er en speciel metode i Go, der bruges til at tilpasse strengrepræsentationen af et objekt, når det udskrives. I dette tilfælde formaterer og returnerer metoden 'String()' en streng, der inkluderer elevens navn og grad.
Dernæst har vi main()-funktionen, hvor to variable, s1 og s2 af 'Student'-typen, erklæres og initialiseres med elevinformation. Til sidst bruger koden funktionen fmt.Println() til at udskrive værdierne af s1 og s2. Da String()-metoden er defineret for 'Student'-typen, kalder Go automatisk denne metode ved udskrivning af 'Student'-objektet. String()-metoden formaterer elevens information ved hjælp af funktionen 'fmt.Sprintf()' og returnerer den formaterede streng.
Følgende output udskriver objektet for 'Student'-typen af stringer-grænsefladen:
Eksempel 4: Golang Type Switch Interface
Så kommer typeskiftgrænsefladen til Go. En type switch er en kontrolstruktur, der giver os mulighed for at inspicere den dynamiske type af en grænsefladeværdi. Følg kildekoden for type switch-interface:
pakke vigtigsteimportere 'fmt
func MyFunction(F1-grænseflade{}) {
switch F1.(type) {
sag int:
fmt.Println(' Type : int , Værdi : ', F1.(dig))
sag streng:
fmt.Println(' \nTyp : snor , Værdi : ', F1.(streng))
sag float64:
fmt.Println(' \nTyp : flyde 64 , Værdi : ', F1.(float64))
Standard:
fmt.Println(' \nTypen er ikke gyldig ')
}
}
func main() {
MyFunction(' Tutorial til Golang-grænseflader ')
MyFunction(89.7)
MyFunction (sand)
}
Her definerer den medfølgende kode en 'MyFunction'-funktion, der tager en 'F1'-parameter af typen 'interface{}'. Dette indikerer, at 'F1' kan acceptere en værdi af enhver type. Inde i funktionen bruges en switch-sætning med 'F1.(type)' for at kontrollere typen af værdien, der sendes til 'MyFunction'. '.(type)'-syntaksen bruges i et typeskift til at få den underliggende dynamiske type af en grænsefladeværdi. Bemærk, at switch cases her håndterer tre specifikke typer: 'int', 'string' og 'float64'. Hvis 'F1'-typen matcher et af disse tilfælde. Den udskriver den tilsvarende type og værdi ved hjælp af typepåstandene (F1.(int), F1.(streng), F1.(float64)). Hvis 'F1'-typen ikke matcher nogen af de definerede tilfælde, udføres standardcaserne, som udskriver 'Typen er ikke gyldig'.
Derefter kaldes 'MyFunction' i main()-funktionen tre gange med forskellige værdier: en streng, en float64 og en Boolean (som ikke håndteres i switch-sætningen).
Outputtet viser demonstrationen af switch-interfacet med typepåstandene:
Eksempel 5: Golang Multiple Interfaces
Desuden tilbyder Go flere grænseflader, der giver den mulighed for at give forskellige sæt adfærd afhængigt af konteksten. Denne funktion kaldes 'flere grænseflader' eller 'grænsefladesammensætning'. Følgende kode demonstrerer implementeringen af flere grænseflader:
pakke vigtigsteimportere 'fmt'
type fugle interface {
træk vejret ()
flyve ()
}
type fugle interface {
foder ()
}
type Hvor struktur {
alder int
}
func ( d hvor ) træk vejret () {
fmt . Println ( 'Due trækker vejret' )
}
func ( d hvor ) flyve () {
fmt . Println ( 'Dueflue' )
}
func ( d hvor ) foder () {
fmt . Println ( 'Due pleje babyer' )
}
func vigtigste () {
var b fugle
d := Hvor {}
b = d
b . træk vejret ()
b . flyve ()
var en fugle
-en = d
-en . foder ()
}
Her definerer vi to grænseflader: 'fugle' og 'fugle'. 'fugle'-grænsefladen erklærer to metoder: breathe() og fly(). Mens 'avians'-grænsefladen erklærer feed()-metoden. Derefter implementerer 'due'-strukturen alle metoderne for både 'fugle' og 'fugle'-grænseflader. Det giver implementeringerne for breathe(), fly() og feed().
Dernæst erklærer vi variablen 'b' af typen 'fugle' i main()-funktionen. En forekomst af en 'due' oprettes og tildeles til 'b' ved hjælp af b = d tildelingen. Da 'due' implementerer alle metoderne i 'fugle'-grænsefladen, er denne opgave gyldig.
Derefter kaldes breathe() og fly() metoderne på 'b', som er af typen 'birds'. På samme måde er en variabel 'a' af typen 'avians' erklæret og tildelt 'due'-forekomsten af 'd'. Da 'dove' implementerer feed()-metoden, der er defineret i 'avians'-grænsefladen, er denne tildeling også gyldig. Feed()-metoden kaldes på 'a', som er af typen 'avians'. Da 'a' indeholder 'dove'-forekomsten, udføres feed()-metoden, der er implementeret af 'dove'.
Outputtet viser, at grænseflademetoderne udføres korrekt:
Konklusion
Vi lærte det grundlæggende i Go-grænseflader og gav praktiske eksempler for at illustrere deres brug. Ved at definere grænseflader og implementere dem med forskellige typer, kan vi skabe fleksible og udvidelige programmer.