Eksempel 1: Golang Empty Interface
Begynn med det tomme grensesnittet{} som omtales som grensesnittet i Go. Det indikerer en type som kan lagre alle slags verdier. Følgende er kildekoden for det tomme grensesnittet i Go:
pakke hoved-import 'fmt'
type Merkkalkulator grensesnitt {}
func hoved- () {
var m Merkekalkulator
fmt . Println ( m )
}
Her gir vi koden der 'MarksCalculator'-grensesnittet ikke har noen spesifiserte metodesignaturer fordi det er tomt. Som et resultat gir den ingen funksjonalitet. Deretter har vi hoved()-funksjonen til dette tomme grensesnittet der en variabel 'm' av typen MarksCalculator er deklarert. Siden grensesnittet er tomt, kan 'm' inneholde en hvilken som helst verdi av hvilken som helst type. I dette tilfellet er 'm' uinitialisert, så den har en nullverdi for sin type som er 'null' for grensesnitt. Når 'm' skrives ut ved å bruke 'fmt.Println' gir den ut 'null' til konsollen.
Utdataene som er hentet er 'null' som forventet fra forrige kildekode:
Eksempel 2: Golang-implementering av grensesnitt
Denne delen demonstrerer implementeringen av Golang-grensesnittet. En type må tilby implementeringen for hver av de spesifiserte metodene i et grensesnitt for å implementere den i Go. Følgende er gitt kildekoden for grensesnittimplementeringen:
pakke hoved-
import (
'fmt'
)
type Vokaler grensesnitt {
Søk vokaler () [] rune
}
type MyStr streng
func ( st MyStr ) Søk vokaler () [] rune {
var vokaler [] rune
til _ , rune := område st {
hvis rune == 'en' || rune == 'Det er' || rune == 'Jeg' || rune == 'O' || rune == 'i' {
vokaler = legge til ( vokaler , rune )
}
}
komme tilbake vokaler
}
func hoved- () {
NewString := MyStr ( 'GoLang-grensesnitt' )
var v1 Vokaler
v1 = NewString
fmt . Printf ( 'Vokaler er %c' , v1 . Søk vokaler ())
}
Her definerer koden et grensesnitt kalt 'Voker' som spesifiserer en enkelt metode SearchVowels() som returnerer en del av runen (type int32). Et grensesnitt gjør det mulig å tilordne enhver type som implementerer denne metodesignaturen til en variabel av grensesnitttypen. Deretter deklareres en ny 'MyStr'-type som er et alias for den underliggende typestrengen. Dette betyr at 'MyStr' arver alle strengmetodene, men er en distinkt type.
Etter det implementerer vi SearchVwels()-metoden for 'MyStr'-typen. Denne metoden skanner inndatastrengen tegn for tegn og sjekker om hvert tegn er en vokal ('a', 'e', 'i', 'o' eller 'u'). Hvis et tegn er en vokal, legges det til vokalskiven.
Inne i main()-funksjonen opprettes en 'NewString'-variabel av 'MyStr'-typen med verdien 'GoLang Interfaces'. Deretter erklæres en 'v1'-variabel av typen 'Vokaler'. Siden 'MyStr' implementerer SearchVwels()-metoden som er definert i 'Vwels'-grensesnittet, kan 'NewString' tilordnes til 'v1'.
Utgangen viser alle vokalene som finnes i den angitte strengen:
Eksempel 3: Golang Stringer Interface
I tillegg har Golang det forhåndsdefinerte 'Stringer'-grensesnittet i 'fmt'-pakken. Den lar en egendefinert type kontrollere strengrepresentasjonen når den er formatert med '%v' verbet i 'fmt'-pakkens utskriftsfunksjoner. Følgende er eksempelkoden for stringer-grensesnittet til Go:
pakke hoved-import (
'fmt'
)
type Student struktur {
Navn streng
Grad streng
}
func ( s Student ) String () streng {
komme tilbake fmt . Sprintf ( '%s er en (n) %s' , s . Navn , s . Grad )
}
func hoved- () {
s1 := Student { 'Elena Gilbert' , 'Datavitenskap' }
s2 := Student { 'Caroline Candice' , 'BBA' }
fmt . Println ( s1 )
fmt . Println ( s2 )
}
Her importerer koden først den nødvendige pakken som er 'fmt' for å skrive ut til konsollen. Deretter definerer vi en strukturtype 'Student' med to felt: 'Navn' og 'Grad'. Denne strukturen representerer en elevs informasjon. Videre opprettes en String()-metode for 'Student'-typen. Denne metoden har en mottaker av typen 'Student' og returnerer en streng. 'String()'-metoden er en spesiell metode i Go som brukes til å tilpasse strengrepresentasjonen av et objekt når det skrives ut. I dette tilfellet formaterer og returnerer 'String()'-metoden en streng som inkluderer studentens navn og grad.
Deretter har vi main()-funksjonen der to variabler, s1 og s2 av 'Student'-typen, er deklarert og initialisert med studentinformasjon. Til slutt bruker koden fmt.Println()-funksjonen for å skrive ut verdiene til s1 og s2. Siden String()-metoden er definert for 'Student'-typen, kaller Go automatisk denne metoden når du skriver ut 'Student'-objektet. String()-metoden formaterer studentens informasjon ved å bruke 'fmt.Sprintf()'-funksjonen og returnerer den formaterte strengen.
Følgende utgang skriver ut objektet til 'Student'-typen til stringer-grensesnittet:
Eksempel 4: Golang Type Switch Interface
Deretter kommer typebrytergrensesnittet til Go. En typebryter er en kontrollstruktur som lar oss inspisere den dynamiske typen til en grensesnittverdi. Følg kildekoden for typebrytergrensesnitt:
pakke hoved-import 'fmt
func MyFunction(F1-grensesnitt{}) {
bryter F1.(type) {
sak int:
fmt.Println(' Type : int , Verdi : ', F1.(du))
saksstreng:
fmt.Println(' \nTyp : streng , Verdi : ', F1.(streng))
case float64:
fmt.Println(' \nTyp : flyte64 , Verdi : ', F1.(float64))
misligholde:
fmt.Println(' \nTypen er ikke gyldig ')
}
}
func main() {
MyFunction(' Opplæring for Golang-grensesnitt ')
MyFunction(89.7)
MyFunction (true)
}
Her definerer den oppgitte koden en 'MyFunction'-funksjon som tar en 'F1'-parameter av typen 'grensesnitt{}'. Dette indikerer at 'F1' kan akseptere en verdi av hvilken som helst type. Inne i funksjonen brukes en switch-setning med 'F1.(type)' for å sjekke typen verdi som sendes til 'MyFunction'. '.(type)'-syntaksen brukes i en typebryter for å få den underliggende dynamiske typen til en grensesnittverdi. Legg merke til at bryterhusene her håndterer tre spesifikke typer: 'int', 'string' og 'float64'. Hvis 'F1'-typen samsvarer med ett av disse tilfellene. Den skriver ut den tilsvarende typen og verdien ved å bruke typepåstandene (F1.(int), F1.(streng), F1.(float64)). Hvis 'F1'-typen ikke samsvarer med noen av de definerte tilfellene, kjøres standardsaken som skriver ut 'Type er ikke gyldig'.
Deretter, innenfor main()-funksjonen, kalles 'MyFunction' tre ganger med forskjellige verdier: en streng, en float64 og en boolsk (som ikke håndteres i switch-setningen).
Utgangen viser demonstrasjonen av brytergrensesnittet med typepåstandene:
Eksempel 5: Golang flere grensesnitt
Dessuten tilbyr Go flere grensesnitt som lar den gi forskjellige sett med atferd avhengig av konteksten. Denne funksjonen kalles 'flere grensesnitt' eller 'grensesnittsammensetning'. Følgende kode demonstrerer implementeringen av flere grensesnitt:
pakke hoved-import 'fmt'
type fugler grensesnitt {
puste ()
fly ()
}
type fugler grensesnitt {
mate ()
}
type Hvor struktur {
alder int
}
func ( d hvor ) puste () {
fmt . Println ( 'Due puster' )
}
func ( d hvor ) fly () {
fmt . Println ( 'Dueflue' )
}
func ( d hvor ) mate () {
fmt . Println ( 'Due pleier babyer' )
}
func hoved- () {
var b fugler
d := Hvor {}
b = d
b . puste ()
b . fly ()
var en fugl
en = d
en . mate ()
}
Her definerer vi to grensesnitt: 'fugler' og 'fugler'. ‘fugler’-grensesnittet erklærer to metoder: pust() og fly(). Mens 'avians'-grensesnittet erklærer feed()-metoden. Deretter implementerer 'due'-strukturen alle metodene for både 'fugler' og 'fugler'-grensesnitt. Det gir implementeringer for breathe(), fly() og feed().
Deretter erklærer vi variabelen 'b' av typen 'fugler' i main()-funksjonen. En forekomst av en 'due' opprettes og tilordnes til 'b' ved å bruke b = d-tilordningen. Ettersom 'dove' implementerer alle metodene til 'birds'-grensesnittet, er denne oppgaven gyldig.
Deretter kalles pust()- og fly()-metodene på 'b' som er av typen 'fugler'. På samme måte er en variabel 'a' av typen 'avians' erklært og tilordnet 'due'-forekomsten av 'd'. Siden 'dove' implementerer feed()-metoden som er definert i 'avians'-grensesnittet, er denne tilordningen også gyldig. Feed()-metoden kalles på 'a' som er av typen 'avians'. Ettersom 'a' inneholder 'dove'-forekomsten, kjøres feed()-metoden som er implementert av 'dove'.
Utdataene viser at metodene for grensesnitt utføres riktig:
Konklusjon
Vi lærte det grunnleggende om Go-grensesnitt og ga praktiske eksempler for å illustrere bruken av dem. Ved å definere grensesnitt og implementere dem med ulike typer, kan vi lage fleksible og utvidbare programmer.