Exempel 1: Golang Empty Interface
Börja med det tomma gränssnittet{} som kallas gränssnittet i Go. Det indikerar en typ som kan lagra alla slags värden. Följande är källkoden för det tomma gränssnittet i Go:
paket huvudimportera 'fmt'
typ MarksCalculator gränssnitt {}
func huvud () {
var m MarksCalculator
fmt . Println ( m )
}
Här tillhandahåller vi koden där 'MarksCalculator'-gränssnittet inte har några specificerade metodsignaturer eftersom det är tomt. Som ett resultat ger det ingen funktionalitet. Därefter har vi main()-funktionen för detta tomma gränssnitt där en variabel 'm' av typen MarksCalculator deklareras. Eftersom gränssnittet är tomt kan 'm' innehålla vilket värde som helst av vilken typ som helst. I det här fallet är 'm' oinitierad, så den har ett nollvärde för sin typ som är 'noll' för gränssnitt. När 'm' skrivs ut med 'fmt.Println' matas det ut 'noll' till konsolen.
Utdata som hämtas är 'noll' som förväntat från den tidigare källkoden:
Exempel 2: Golang-implementering av gränssnitt
Det här avsnittet visar implementeringen av Golang-gränssnittet. En typ måste erbjuda implementeringen för var och en av de angivna metoderna i ett gränssnitt för att kunna implementera den i Go. Följande är givet källkoden för gränssnittsimplementeringen:
paket huvud
importera (
'fmt'
)
typ Vokaler gränssnitt {
Sök vokaler () [] runa
}
typ MyStr sträng
func ( st MyStr ) Sök vokaler () [] runa {
var vokaler [] runa
för _ , runa := räckvidd st {
om runa == 'a' || runa == 'Det är' || runa == 'jag' || runa == 'O' || runa == 'i' {
vokaler = bifoga ( vokaler , runa )
}
}
lämna tillbaka vokaler
}
func huvud () {
NewString := MyStr ( 'GoLang-gränssnitt' )
var v1 Vokaler
v1 = NewString
fmt . Printf ( 'Vokaler är %c' , v1 . Sök vokaler ())
}
Här definierar koden ett gränssnitt som heter 'Vokelser' som specificerar en enda metod SearchVowels() som returnerar en del av runan (typ int32). Ett gränssnitt gör att alla typer som implementerar denna metodsignatur kan tilldelas en variabel av gränssnittstypen. Sedan deklareras en ny 'MyStr'-typ som är ett alias för den underliggande typsträngen. Detta betyder att 'MyStr' ärver alla metoder för sträng men är en distinkt typ.
Efter det implementerar vi metoden SearchVwels() för typen 'MyStr'. Den här metoden skannar inmatningssträngen tecken för tecken och kontrollerar om varje tecken är en vokal ('a', 'e', 'i', 'o' eller 'u'). Om ett tecken är en vokal, läggs det till vokalskivan.
Inuti main()-funktionen skapas en 'NewString'-variabel av typen 'MyStr' med värdet 'GoLang Interfaces'. Därefter deklareras en 'v1'-variabel av typen 'Vokaler'. Eftersom 'MyStr' implementerar metoden SearchVwels() som är definierad i 'Vwels'-gränssnittet, kan 'NewString' tilldelas 'v1'.
Utdatan visar alla de vokaler som finns i den angivna strängen:
Exempel 3: Golang Stringer Interface
Dessutom har Golang det fördefinierade 'Stringer'-gränssnittet i 'fmt'-paketet. Det tillåter en anpassad typ att styra sin strängrepresentation när den formateras med verbet '%v' i 'fmt'-paketets utskriftsfunktioner. Följande är exempelkoden för stringer-gränssnittet för Go:
paket huvudimportera (
'fmt'
)
typ Studerande struktur {
namn sträng
Grad sträng
}
func ( s Student ) Sträng () sträng {
lämna tillbaka fmt . Sprintf ( '%s är en (n) %s' , s . namn , s . Grad )
}
func huvud () {
s1 := Studerande { 'Elena Gilbert' , 'Datavetenskap' }
s2 := Studerande { 'Caroline Candice' , 'BBA' }
fmt . Println ( s1 )
fmt . Println ( s2 )
}
Här importerar koden först det nödvändiga paketet som är 'fmt' för att skriva ut till konsolen. Sedan definierar vi en strukturtyp 'Student' med två fält: 'Namn' och 'Grad'. Denna struktur representerar en elevs information. Vidare skapas en String()-metod för typen 'Student'. Denna metod har en mottagare av typen 'Student' och returnerar en sträng. Metoden 'String()' är en speciell metod i Go som används för att anpassa strängrepresentationen av ett objekt när det skrivs ut. I det här fallet formaterar och returnerar metoden 'String()' en sträng som innehåller studentens namn och examen.
Därefter har vi funktionen main() där två variabler, s1 och s2 av typen 'Student', deklareras och initieras med elevinformation. Slutligen använder koden funktionen fmt.Println() för att skriva ut värdena för s1 och s2. Eftersom String()-metoden är definierad för 'Student'-typen, anropar Go automatiskt denna metod när du skriver ut 'Student'-objektet. String()-metoden formaterar elevens information med funktionen 'fmt.Sprintf()' och returnerar den formaterade strängen.
Följande utdata skriver ut objektet av typen 'Student' för stringer-gränssnittet:
Exempel 4: Golang Type Switch Interface
Sedan kommer typväxlingsgränssnittet för Go. En typomkopplare är en kontrollstruktur som låter oss inspektera den dynamiska typen av ett gränssnittsvärde. Följ källkoden för typväxlingsgränssnitt:
paket huvudimportera 'fmt
func MyFunction(F1-gränssnitt{}) {
switch F1.(typ) {
fall int:
fmt.Println(' Typ : int , Värde : ', F1.(du))
case sträng:
fmt.Println(' \nTyp : sträng , Värde : ', F1.(sträng))
case float64:
fmt.Println(' \nTyp : flyta64 , Värde : ', F1.(float64))
standard:
fmt.Println(' \nTypen är inte giltig ')
}
}
func main() {
MyFunction(' Handledning för Golang-gränssnitt ')
MyFunction(89.7)
MyFunction(true)
}
Här definierar den tillhandahållna koden en 'MyFunction'-funktion som tar en 'F1'-parameter av typen 'interface{}'. Detta indikerar att 'F1' kan acceptera ett värde av vilken typ som helst. Inuti funktionen används en switch-sats med “F1.(type)” för att kontrollera vilken typ av värde som skickas till “MyFunction”. '.(type)'-syntaxen används i en typväxling för att få den underliggande dynamiska typen av ett gränssnittsvärde. Observera att växellådan här hanterar tre specifika typer: 'int', 'sträng' och 'float64'. Om 'F1'-typen matchar ett av dessa fall. Den skriver ut motsvarande typ och värde med hjälp av typpåståenden (F1.(int), F1.(sträng), F1.(float64)). Om 'F1'-typen inte matchar något av de definierade fallen, exekveras standardfallet som skriver ut 'Typen är inte giltig'.
Därefter, inom main()-funktionen, anropas 'MyFunction' tre gånger med olika värden: en sträng, en float64 och en Boolean (som inte hanteras i switch-satsen).
Utgången visar demonstrationen av switchgränssnittet med typpåståenden:
Exempel 5: Golang Multiple Interfaces
Dessutom erbjuder Go flera gränssnitt som gör att den kan tillhandahålla olika uppsättningar beteenden beroende på sammanhanget. Denna funktion kallas 'flera gränssnitt' eller 'gränssnittssammansättning'. Följande kod visar implementeringen av flera gränssnitt:
paket huvudimportera 'fmt'
typ fåglar gränssnitt {
andas ()
flyga ()
}
typ fåglar gränssnitt {
utfodra ()
}
typ Var struktur {
ålder int
}
func ( d var ) andas () {
fmt . Println ( 'Duva andas' )
}
func ( d var ) flyga () {
fmt . Println ( 'Duvfluga' )
}
func ( d var ) utfodra () {
fmt . Println ( 'Duva fostrar bebisar' )
}
func huvud () {
var b fåglar
d := Var {}
b = d
b . andas ()
b . flyga ()
var en fågel
a = d
a . utfodra ()
}
Här definierar vi två gränssnitt: 'fåglar' och 'fåglar'. 'Fåglar'-gränssnittet förklarar två metoder: breathe() och fly(). Medan 'avians'-gränssnittet deklarerar feed()-metoden. Sedan implementerar 'duvan'-strukturen alla metoder för både 'fåglar' och 'fåglar'-gränssnitt. Det tillhandahåller implementeringarna för breathe(), fly() och feed().
Därefter deklarerar vi variabeln 'b' av typen 'fåglar' i main()-funktionen. En instans av en 'duva' skapas och tilldelas till 'b' med hjälp av tilldelningen b = d. Eftersom 'duva' implementerar alla metoder för 'fåglar'-gränssnittet, är denna uppgift giltig.
Sedan anropas metoderna breathe() och fly() på 'b' som är av typen 'fåglar'. På liknande sätt deklareras en variabel 'a' av typen 'fåglar' och tilldelas med 'duva'-instansen av 'd'. Eftersom 'dove' implementerar feed()-metoden som är definierad i 'avians'-gränssnittet, är denna tilldelning också giltig. Metoden feed() anropas på 'a' som är av typen 'avians'. Eftersom 'a' innehåller 'dove'-instansen, exekveras feed()-metoden som implementeras av 'dove'.
Utdata visar att metoderna för gränssnitt exekveras korrekt:
Slutsats
Vi lärde oss grunderna i Go-gränssnitt och gav praktiska exempel för att illustrera deras användning. Genom att definiera gränssnitt och implementera dem med olika typer kan vi skapa flexibla och utbyggbara program.