Voorbeeld 1: Golang lege interface
Begin met de lege interface{} die in Go de interface wordt genoemd. Het geeft een type aan dat elke soort waarde kan opslaan. Het volgende is de broncode voor de lege interface in Go:
pakket voornaamstimporteren 'fmt'
type Merkencalculator koppel {}
func voornaamst () {
was m MarksCalculator
fmt . Println ( M )
}
Hier geven we de code waar de 'MarksCalculator' -interface geen gespecificeerde methodehandtekeningen heeft omdat deze leeg is. Als gevolg hiervan biedt het geen functionaliteit. Vervolgens hebben we de functie main() van deze lege interface waar een variabele 'm' van het type MarksCalculator wordt gedeclareerd. Omdat de interface leeg is, kan 'm' elke waarde van elk type bevatten. In dit geval is 'm' niet geïnitialiseerd, dus heeft het een nulwaarde voor zijn type, wat 'nul' is voor interfaces. Wanneer 'm' wordt afgedrukt met behulp van 'fmt.Println', wordt 'nil' uitgevoerd naar de console.
De uitvoer die wordt opgehaald is 'nul' zoals verwacht van de vorige broncode:
Voorbeeld 2: Golang-implementatie van interface
Deze sectie demonstreert de implementatie van de Golang-interface. Een type moet de implementatie bieden voor elk van de gespecificeerde methoden in een interface om het in Go te implementeren. Het volgende is de gegeven broncode voor de interface-implementatie:
pakket voornaamst
importeren (
'fmt'
)
type klinkers koppel {
ZoekKlinkers () [] rune
}
type MijnStr snaar
func ( st MyStr ) ZoekKlinkers () [] rune {
was klinkers [] rune
voor _ , rune := bereik st {
als rune == 'A' || rune == 'Het is' || rune == 'i' || rune == 'O' || rune == 'in' {
klinkers = toevoegen ( klinkers , rune )
}
}
opbrengst klinkers
}
func voornaamst () {
NieuweString := MijnStr ( 'GoLang-interfaces' )
was v1 klinkers
v1 = NieuweString
fmt . Printf ( 'Klinkers zijn %c' , v1 . ZoekKlinkers ())
}
Hier definieert de code een interface met de naam 'Vowels' die een enkele methode SearchVowels() specificeert die een deel van de rune retourneert (type int32). Met een interface kan elk type dat deze methodehandtekening implementeert, worden toegewezen aan een variabele van het interfacetype. Vervolgens wordt een nieuw 'MyStr' -type gedeclareerd dat een alias is voor de onderliggende typereeks. Dit betekent dat 'MyStr' alle methoden van string overerft, maar een apart type is.
Daarna implementeren we de methode SearchVowels() voor het type 'MyStr'. Deze methode scant de ingevoerde tekenreeks teken voor teken en controleert of elk teken een klinker is ('a', 'e', 'i', 'o' of 'u'). Als een teken een klinker is, wordt het toegevoegd aan de klinkerschijf.
Binnen de functie main() wordt een variabele 'NewString' van het type 'MyStr' gemaakt met de waarde 'GoLang Interfaces'. Vervolgens wordt een variabele 'v1' van het type 'Klinkers' gedeclareerd. Aangezien “MyStr” de SearchVowels()-methode implementeert die is gedefinieerd in de “Vowels”-interface, kan de “NewString” worden toegewezen aan “v1”.
De uitvoer toont alle reeksen klinkers die in de opgegeven tekenreeks voorkomen:
Voorbeeld 3: Golang Stringer-interface
Bovendien heeft Golang de vooraf gedefinieerde 'Stringer' -interface in het 'fmt' -pakket. Het staat een aangepast type toe om zijn tekenreeksrepresentatie te regelen wanneer het is geformatteerd met het werkwoord '% v' in de afdrukfuncties van het 'fmt' -pakket. Het volgende is de voorbeeldcode voor de stringer-interface van Go:
pakket voornaamstimporteren (
'fmt'
)
type Student structuur {
Naam snaar
Rang snaar
}
func ( s leerling ) Snaar () snaar {
opbrengst fmt . Sprintf ( '%s is een(n) %s' , S . Naam , S . Rang )
}
func voornaamst () {
s1 := Student { 'Elena Gilbert' , 'Computertechnologie' }
s2 := Student { 'Carolina Candice' , 'BBA' }
fmt . Println ( s1 )
fmt . Println ( s2 )
}
Hier importeert de code eerst het benodigde pakket dat 'fmt' is om naar de console af te drukken. Vervolgens definiëren we een structuurtype 'Student' met twee velden: 'Naam' en 'Graad'. Deze structuur vertegenwoordigt de informatie van een student. Verder wordt een String()-methode voor het type 'Student' gemaakt. Deze methode heeft een ontvanger van het type 'Student' en retourneert een string. De methode 'String()' is een speciale methode in Go die wordt gebruikt om de tekenreeksrepresentatie van een object aan te passen wanneer het wordt afgedrukt. In dit geval wordt met de methode 'String()' een tekenreeks opgemaakt en geretourneerd die de naam en het diploma van de student bevat.
Vervolgens hebben we de functie main() waar twee variabelen, s1 en s2 van het type 'Student', worden gedeclareerd en geïnitialiseerd met studentinformatie. Ten slotte gebruikt de code de functie fmt.Println() om de waarden van s1 en s2 af te drukken. Aangezien de methode String() is gedefinieerd voor het type 'Student', roept Go deze methode automatisch aan wanneer het object 'Student' wordt afgedrukt. De methode String() maakt de informatie van de leerling op met behulp van de functie 'fmt.Sprintf()' en retourneert de opgemaakte tekenreeks.
De volgende uitvoer drukt het object af van het type 'Student' van de stringerinterface:
Voorbeeld 4: Golang-type schakelinterface
Dan komt de typewisselinterface van Go. Een typeschakelaar is een besturingsstructuur waarmee we het dynamische type van een interfacewaarde kunnen inspecteren. Volg de broncode van het type switch-interface:
pakket voornaamstimporteren 'fmt
func MijnFunctie(F1-interface{}) {
schakelaar F1.(type) {
hoofdlettergebruik:
fmt.Println(' Type : int , Waarde : ', F1.(jij))
hoofdletterreeks:
fmt.Println(' \nType : snaar , Waarde : ', F1.(tekenreeks))
geval float64:
fmt.Println(' \nType : vlotter64 , Waarde : ', F1.(zweven64))
standaard:
fmt.Println(' \nType is niet geldig ')
}
}
hoofdfunctie() {
MijnFunctie(' Golang-interfaces-zelfstudie ')
MijnFunctie(89.7)
MijnFunctie(waar)
}
Hier definieert de verstrekte code een 'MyFunction' -functie die een 'F1' -parameter van het type 'interface{}' gebruikt. Dit geeft aan dat 'F1' een waarde van elk type kan accepteren. Binnen de functie wordt een switch-instructie gebruikt met 'F1.(type)' om het type waarde te controleren dat wordt doorgegeven aan 'MyFunction'. De syntaxis '.(type)' wordt gebruikt in een typeschakelaar om het onderliggende dynamische type van een interfacewaarde te krijgen. Merk op dat de switch-cases hier drie specifieke typen behandelen: 'int', 'string' en 'float64'. Als het type 'F1' overeenkomt met een van deze gevallen. Het drukt het overeenkomstige type en de waarde af met behulp van de typebevestigingen (F1.(int), F1.(string), F1.(float64)). Als het type 'F1' niet overeenkomt met een van de gedefinieerde gevallen, wordt het standaardgeval uitgevoerd dat 'Type is niet geldig' afdrukt.
Daarna wordt binnen de functie main() 'MyFunction' drie keer aangeroepen met verschillende waarden: een string, een float64 en een Boolean (die niet wordt verwerkt in de switch-instructie).
De uitvoer toont de demonstratie van de switch-interface met de typeverklaringen:
Voorbeeld 5: Golang meerdere interfaces
Bovendien biedt Go meerdere interfaces waarmee het verschillende gedragingen kan bieden, afhankelijk van de context. Deze functie wordt 'meerdere interfaces' of 'interfacesamenstelling' genoemd. De volgende code demonstreert de implementatie van meerdere interfaces:
pakket voornaamstimporteren 'fmt'
type vogels koppel {
ademen ()
vlieg ()
}
type vogels koppel {
voer ()
}
type Waar structuur {
leeftijd int
}
func ( d waar ) ademen () {
fmt . Println ( 'Duif ademt' )
}
func ( d waar ) vlieg () {
fmt . Println ( 'duif vlieg' )
}
func ( d waar ) voer () {
fmt . Println ( 'Dove koestert baby's' )
}
func voornaamst () {
was b vogels
D := Waar {}
B = D
B . ademen ()
B . vlieg ()
was een vogel
A = D
A . voer ()
}
Hier definiëren we twee interfaces: 'vogels' en 'avians'. De 'birds'-interface declareert twee methoden: breath() en fly(). Terwijl de “avians”-interface de methode feed() declareert. Vervolgens implementeert de 'duif' -structuur alle methoden van zowel de 'vogels'- als de 'avians'-interfaces. Het biedt de implementaties voor breath(), fly() en feed().
Vervolgens declareren we de variabele 'b' van het type 'birds' binnen de functie main(). Er wordt een exemplaar van een 'duif' gemaakt en toegewezen aan 'b' met behulp van de b = d-toewijzing. Aangezien 'duif' alle methoden van de 'vogels' -interface implementeert, is deze toewijzing geldig.
Vervolgens worden de breath() en fly() methoden aangeroepen op 'b', wat van het type 'birds' is. Evenzo wordt een variabele 'a' van het type 'avians' gedeclareerd en toegewezen aan de 'duif'-instantie van 'd'. Aangezien 'dove' de feed()-methode implementeert die is gedefinieerd in de 'avians'-interface, is deze toewijzing ook geldig. De methode feed() wordt aangeroepen op 'a', die van het type 'avians' is. Aangezien 'a' de instantie 'dove' bevat, wordt de methode feed() die door de 'dove' is geïmplementeerd, uitgevoerd.
De uitvoer laat zien dat de methoden van interfaces correct worden uitgevoerd:
Conclusie
We leerden de basisprincipes van Go-interfaces en gaven praktische voorbeelden om het gebruik ervan te illustreren. Door interfaces te definiëren en deze met verschillende typen te implementeren, kunnen we flexibele en uitbreidbare programma's maken.