Exemplul 1: Golang interfață goală
Începeți cu interfața goală{}, care este denumită interfață în Go. Indică un tip care poate stoca orice fel de valoare. Următorul este codul sursă pentru interfața goală din Go:
pachet principalimport 'fmt'
tip MarksCalculator interfață {}
func principal () {
a fost m MarksCalculator
fmt . Println ( m )
}
Aici, oferim codul în care interfața „MarksCalculator” nu are nicio semnătură de metodă specificată, deoarece este goală. Drept urmare, nu oferă nicio funcționalitate. În continuare, avem funcția main() a acestei interfețe goale în care este declarată o variabilă „m” de tip MarksCalculator. Deoarece interfața este goală, „m” poate conține orice valoare de orice tip. În acest caz, „m” este neinițializat, deci are o valoare zero pentru tipul său, care este „nul” pentru interfețe. Când „m” este tipărit folosind „fmt.Println”, acesta trimite „nil” în consolă.
Ieșirea care este preluată este „nulă”, așa cum era de așteptat din codul sursă anterior:
Exemplul 2: Implementarea Golang a interfeței
Această secțiune demonstrează implementarea interfeței Golang. Un tip trebuie să ofere implementarea pentru fiecare dintre metodele specificate într-o interfață pentru a o implementa în Go. Următorul este dat codul sursă pentru implementarea interfeței:
pachet principal
import (
'fmt'
)
tip Vocalele interfață {
Caută vocale () [] rune
}
tip MyStr şir
func ( st MyStr ) Caută vocale () [] rune {
a fost vocale [] rune
pentru _ , rune := gamă Sf {
dacă rune == 'A' || rune == 'Este' || rune == 'eu' || rune == 'O' || rune == 'în' {
vocale = adăuga ( vocale , rune )
}
}
întoarcere vocale
}
func principal () {
NewString := MyStr ( „Interfețe GoLang” )
a fost v1 Vocale
v1 = NewString
fmt . Printf ( „Vocalele sunt %c” , v1 . Caută vocale ())
}
Aici, codul definește o interfață numită „Vowels” care specifică o singură metodă SearchVowels() care returnează o porțiune a runei (tip int32). O interfață permite oricărui tip care implementează această semnătură de metodă să fie atribuit unei variabile a tipului de interfață. Apoi, un nou tip „MyStr” este declarat, care este un alias pentru șirul de tip subiacent. Aceasta înseamnă că „MyStr” moștenește toate metodele de șir, dar este un tip distinct.
După aceea, implementăm metoda SearchVowels() pentru tipul „MyStr”. Această metodă scanează șirul de intrare caracter cu caracter și verifică dacă fiecare caracter este o vocală („a”, „e”, „i”, „o” sau „u”). Dacă un caracter este o vocală, acesta este atașat la felia vocală.
În interiorul funcției main(), este creată o variabilă „NewString” de tip „MyStr” cu valoarea „GoLang Interfaces”. În continuare, este declarată o variabilă „v1” de tip „Vocale”. Deoarece „MyStr” implementează metoda SearchVowels() care este definită în interfața „Vowels”, „NewString” poate fi atribuit „v1”.
Ieșirea afișează toată matricea de vocale care se găsesc în șirul specificat:
Exemplul 3: Interfața Golang Stringer
În plus, Golang are interfața „Stringer” predefinită în pachetul „fmt”. Permite unui tip personalizat să-și controleze reprezentarea șirurilor atunci când este formatat cu verbul „%v” în funcțiile de imprimare ale pachetului „fmt”. Următorul este exemplul de cod pentru interfața stringer a Go:
pachet principalimport (
'fmt'
)
tip Student struct {
Nume şir
grad şir
}
func ( s Student ) Şir () şir {
întoarcere fmt . Sprintf ( „%s este un(n) %s” , s . Nume , s . grad )
}
func principal () {
s1 := Student { „Elena Gilbert” , 'Informatică' }
s2 := Student { „Caroline Candice” , 'BBA' }
fmt . Println ( s1 )
fmt . Println ( s2 )
}
Aici, codul importă mai întâi pachetul necesar care este „fmt” pentru a fi imprimat pe consolă. Apoi, definim un tip de structură „Student” cu două câmpuri: „Nume” și „Grad”. Această structură reprezintă informațiile unui student. În plus, este creată o metodă String() pentru tipul „Student”. Această metodă are un receptor de tip „Student” și returnează un șir. Metoda „String()” este o metodă specială în Go care este utilizată pentru a personaliza reprezentarea șirului unui obiect atunci când este imprimat. În acest caz, metoda „String()” formatează și returnează un șir care include numele și gradul studentului.
În continuare, avem funcția main() în care două variabile, s1 și s2 de tip „Student”, sunt declarate și inițializate cu informații despre student. În cele din urmă, codul folosește funcția fmt.Println() pentru a imprima valorile lui s1 și s2. Deoarece metoda String() este definită pentru tipul „Student”, Go apelează automat această metodă atunci când tipăriți obiectul „Student”. Metoda String() formatează informațiile elevului folosind funcția „fmt.Sprintf()” și returnează șirul formatat.
Următoarea ieșire tipărește obiectul tipului „Student” al interfeței stringer:
Exemplul 4: Interfață de comutare de tip Golang
Apoi vine interfața de comutare de tip a Go. Un comutator de tip este o structură de control care ne permite să inspectăm tipul dinamic al unei valori de interfață. Urmați codul sursă al interfeței comutatorului de tip:
pachet principalimport 'fmt
func Funcția mea (interfață F1{}) {
comutator F1.(tip) {
caz int:
fmt.Println(' Tip : int , Valoare : ', F1.(tu))
șir de caz:
fmt.Println(' \nTastați : şir , Valoare : ', F1.(șir))
case float64:
fmt.Println(' \nTastați : float64 , Valoare : ', F1.(float64))
Mod implicit:
fmt.Println(' \nTipul nu este valid ')
}
}
func principal() {
Funcția mea(' Tutorial interfețe Golang ')
Funcția mea (89,7)
Funcția mea (adevărat)
}
Aici, codul furnizat definește o funcție „MyFunction” care ia un parametru „F1” de tip „interfață{}”. Aceasta indică faptul că „F1” poate accepta o valoare de orice tip. În interiorul funcției, o instrucțiune switch este utilizată cu „F1.(type)” pentru a verifica tipul valorii care este transmisă „MyFunction”. Sintaxa „.(type)” este utilizată într-un comutator de tip pentru a obține tipul dinamic subiacent al unei valori de interfață. Rețineți că cazurile de comutare se ocupă de trei tipuri specifice: „int”, „string” și „float64”. Dacă tipul „F1” se potrivește cu unul dintre aceste cazuri. Tipărește tipul și valoarea corespunzătoare folosind aserțiunile de tip (F1.(int), F1.(string), F1.(float64)). Dacă tipul „F1” nu se potrivește cu niciunul dintre cazurile definite, se execută cazul implicit, care afișează „Tipul nu este valid”.
Ulterior, în cadrul funcției main(), „MyFunction” este apelat de trei ori cu valori diferite: un șir, un float64 și un boolean (care nu este tratat în instrucțiunea switch).
Ieșirea afișează demonstrația interfeței comutatorului cu afirmațiile de tip:
Exemplul 5: Interfețe multiple Golang
Mai mult, Go oferă mai multe interfețe care îi permit să ofere seturi diferite de comportamente în funcție de context. Această caracteristică se numește „interfețe multiple” sau „compoziția interfeței”. Următorul cod demonstrează implementarea mai multor interfețe:
pachet principalimport 'fmt'
tip păsări interfata {
a respira ()
a zbura ()
}
tip aviare interfata {
a hrani ()
}
tip Unde struct {
vârstă int
}
func ( d unde ) a respira () {
fmt . Println ( „Porumbelul respiră” )
}
func ( d unde ) a zbura () {
fmt . Println ( „Zboară porumbel” )
}
func ( d unde ) a hrani () {
fmt . Println ( „Porumbelul hrănește bebelușii” )
}
func principal () {
a fost b păsări
d := Unde {}
b = d
b . a respira ()
b . a zbura ()
a fost un aviar
A = d
A . a hrani ()
}
Aici definim două interfețe: „păsări” și „aviari”. Interfața „păsări” declară două metode: breathe() și fly(). În timp ce interfața „avians” declară metoda feed(). Apoi, structura „dove” implementează toate metodele atât ale interfețelor „păsări”, cât și „aviari”. Oferă implementările pentru breathe(), fly() și feed().
În continuare, declarăm variabila „b” de tip „păsări” în cadrul funcției main(). O instanță a unui „porumbel” este creată și atribuită lui „b” folosind atribuirea b = d. Deoarece „dove” implementează toate metodele interfeței „păsări”, această atribuire este valabilă.
Apoi, metodele breathe() și fly() sunt apelate pe „b” care este de tip „păsări”. În mod similar, o variabilă „a” de tip „avian” este declarată și atribuită cu instanța „dove” a „d”. Deoarece „dove” implementează metoda feed() care este definită în interfața „avians”, această atribuire este de asemenea valabilă. Metoda feed() este apelată pe „a” care este de tip „aviari”. Deoarece „a” deține instanța „dove”, metoda feed() care este implementată de „dove” este executată.
Rezultatul arată că metodele interfețelor sunt executate corect:
Concluzie
Am învățat elementele de bază ale interfețelor Go și am oferit exemple practice pentru a ilustra utilizarea acestora. Prin definirea interfețelor și implementarea lor cu diferite tipuri, putem crea programe flexibile și extensibile.