Esempio 1: interfaccia vuota Golang
Inizia con l'interfaccia vuota{} che viene chiamata interfaccia in Go. Indica un tipo che può memorizzare qualsiasi tipo di valore. Quello che segue è il codice sorgente per l'interfaccia vuota in Go:
pacchetto principaleimportare 'fmt'
tipo Calcolatrice dei voti interfaccia {}
funz principale () {
era m MarksCalculator
fmt . Stampaln ( M )
}
Qui, forniamo il codice in cui l'interfaccia 'MarksCalculator' non ha firme di metodo specificate perché è vuota. Di conseguenza, non fornisce alcuna funzionalità. Successivamente, abbiamo la funzione main() di questa interfaccia vuota in cui è dichiarata una variabile 'm' di tipo MarksCalculator. Poiché l'interfaccia è vuota, 'm' può contenere qualsiasi valore di qualsiasi tipo. In questo caso, 'm' non è inizializzato, quindi ha un valore zero per il suo tipo che è 'nil' per le interfacce. Quando 'm' viene stampato utilizzando 'fmt.Println' restituisce 'nil' alla console.
L'output recuperato è 'nil' come previsto dal codice sorgente precedente:
Esempio 2: Implementazione Golang dell'interfaccia
Questa sezione illustra l'implementazione dell'interfaccia Golang. Un tipo deve offrire l'implementazione per ciascuno dei metodi specificati in un'interfaccia per poterlo implementare in Go. Di seguito è riportato il codice sorgente per l'implementazione dell'interfaccia:
pacchetto principale
importare (
'fmt'
)
tipo Vocali interfaccia {
CercaVocali () [] runa
}
tipo MyStr corda
funz ( st MyStr ) CercaVocali () [] runa {
era vocali [] runa
per _ , runa := allineare st {
Se runa == 'UN' || runa == 'È' || runa == 'io' || runa == 'O' || runa == 'In' {
vocali = aggiungere ( vocali , runa )
}
}
ritorno vocali
}
funz principale () {
NewString := MyStr ( 'Interfacce GoLang' )
era v1 Vocali
v1 = NewString
fmt . Stampaf ( 'Le vocali sono %c' , v1 . CercaVocali ())
}
Qui, il codice definisce un'interfaccia denominata 'Vowels' che specifica un singolo metodo SearchVowels() che restituisce una porzione della runa (tipo int32). Un'interfaccia consente di assegnare qualsiasi tipo che implementa questa firma del metodo a una variabile del tipo di interfaccia. Quindi, viene dichiarato un nuovo tipo 'MyStr' che è un alias per la stringa di tipo sottostante. Ciò significa che 'MyStr' eredita tutti i metodi di string ma è un tipo distinto.
Successivamente, implementiamo il metodo SearchVowels() per il tipo 'MyStr'. Questo metodo scansiona la stringa di input carattere per carattere e controlla se ogni carattere è una vocale ('a', 'e', 'i', 'o' o 'u'). Se un carattere è una vocale, viene aggiunto alla parte vocale.
All'interno della funzione main() viene creata una variabile “NewString” di tipo “MyStr” con il valore “GoLang Interfaces”. Successivamente, viene dichiarata una variabile “v1” di tipo “Vocali”. Poiché 'MyStr' implementa il metodo SearchVowels() definito nell'interfaccia 'Vowels', la 'NewString' può essere assegnata a 'v1'.
L'output mostra tutto l'array di vocali che si trovano nella stringa specificata:
Esempio 3: Interfaccia Golang Stringer
Inoltre, Golang ha l'interfaccia predefinita 'Stringer' nel pacchetto 'fmt'. Consente a un tipo personalizzato di controllare la sua rappresentazione di stringa quando formattato con il verbo '%v' nelle funzioni di stampa del pacchetto 'fmt'. Di seguito è riportato il codice di esempio per l'interfaccia stringer di Go:
pacchetto principaleimportare (
'fmt'
)
tipo Alunno struct {
Nome corda
Grado corda
}
funz ( s Studente ) Corda () corda {
ritorno fmt . Sprintf ( '%s è un(n) %s' , S . Nome , S . Grado )
}
funz principale () {
s1 := Alunno { 'Elena Gilbert' , 'Informatica' }
s2 := Alunno { 'Carolina Candice' , 'BBA' }
fmt . Stampaln ( s1 )
fmt . Stampaln ( s2 )
}
Qui, il codice importa prima il pacchetto necessario che è 'fmt' da stampare sulla console. Quindi, definiamo un tipo di struttura 'Studente' con due campi: 'Nome' e 'Laurea'. Questa struttura rappresenta le informazioni di uno studente. Inoltre, viene creato un metodo String() per il tipo 'Student'. Questo metodo ha un ricevitore di tipo “Student” e restituisce una stringa. Il metodo 'String()' è un metodo speciale in Go che viene utilizzato per personalizzare la rappresentazione di stringa di un oggetto quando viene stampato. In questo caso, il metodo “String()” formatta e restituisce una stringa che include il nome e il titolo dello studente.
Successivamente, abbiamo la funzione main() dove due variabili, s1 e s2 di tipo “Student”, sono dichiarate e inizializzate con le informazioni sullo studente. Infine, il codice utilizza la funzione fmt.Println() per stampare i valori di s1 e s2. Poiché il metodo String() è definito per il tipo 'Student', Go chiama automaticamente questo metodo quando stampa l'oggetto 'Student'. Il metodo String() formatta le informazioni dello studente utilizzando la funzione 'fmt.Sprintf()' e restituisce la stringa formattata.
Il seguente output stampa l'oggetto del tipo 'Student' dell'interfaccia stringer:
Esempio 4: Interfaccia Switch di tipo Golang
Poi arriva l'interfaccia di cambio di tipo di Go. Uno switch di tipo è una struttura di controllo che ci consente di ispezionare il tipo dinamico di un valore di interfaccia. Segui il codice sorgente dell'interfaccia di tipo switch:
pacchetto principaleimportare 'fmt
func MiaFunzione(interfaccia F1{}) {
cambia F1.(tipo) {
caso int:
fmt.Println(' Tipo : int , Valore : ', F1.(tu))
stringa caso:
fmt.Println(' \nDigitare : corda , Valore : ', F1.(stringa))
caso float64:
fmt.Println(' \nDigitare : galleggiante64 , Valore : ', F1.(float64))
predefinito:
fmt.Println(' \nIl tipo non è valido ')
}
}
funzione principale() {
Mia funzione(' Esercitazione sulle interfacce Golang ')
MiaFunzione(89.7)
MiaFunzione(vero)
}
Qui, il codice fornito definisce una funzione 'MyFunction' che accetta un parametro 'F1' di tipo 'interface{}'. Ciò indica che 'F1' può accettare un valore di qualsiasi tipo. All'interno della funzione, viene utilizzata un'istruzione switch con 'F1.(type)' per verificare il tipo di valore passato a 'MyFunction'. La sintassi '.(type)' viene utilizzata in un'opzione di tipo per ottenere il tipo dinamico sottostante di un valore di interfaccia. Si noti che i casi switch qui gestiscono tre tipi specifici: 'int', 'string' e 'float64'. Se il tipo 'F1' corrisponde a uno di questi casi. Stampa il tipo e il valore corrispondenti utilizzando le asserzioni di tipo (F1.(int), F1.(string), F1.(float64)). Se il tipo 'F1' non corrisponde a nessuno dei casi definiti, viene eseguito il caso predefinito che stampa 'Tipo non valido'.
Successivamente, all'interno della funzione main(), 'MyFunction' viene chiamato tre volte con valori diversi: una stringa, un float64 e un booleano (che non viene gestito nell'istruzione switch).
L'output mostra la dimostrazione dell'interfaccia switch con le asserzioni di tipo:
Esempio 5: interfacce multiple Golang
Inoltre, Go offre molteplici interfacce che gli consentono di fornire diversi set di comportamenti a seconda del contesto. Questa funzione è chiamata 'interfacce multiple' o 'composizione dell'interfaccia'. Il codice seguente illustra l'implementazione di più interfacce:
pacchetto principaleimportare 'fmt'
tipo uccelli interfaccia {
respirare ()
volare ()
}
tipo uccelli interfaccia {
foraggio ()
}
tipo dove struct {
età int
}
funz ( d dove ) respirare () {
fmt . Stampaln ( 'Colomba respira' )
}
funz ( d dove ) volare () {
fmt . Stampaln ( 'Colomba vola' )
}
funz ( d dove ) foraggio () {
fmt . Stampaln ( 'La colomba nutre i bambini' )
}
funz principale () {
era b uccelli
D := dove {}
B = D
B . respirare ()
B . volare ()
era un'aviaria
UN = D
UN . foraggio ()
}
Qui definiamo due interfacce: 'birds' e 'avians'. L'interfaccia 'birds' dichiara due metodi: breath() e fly(). Mentre l'interfaccia 'avians' dichiara il metodo feed(). Quindi, la struttura 'dove' implementa tutti i metodi delle interfacce 'birds' e 'avians'. Fornisce le implementazioni per breath(), fly() e feed().
Successivamente, dichiariamo la variabile 'b' di tipo 'birds' all'interno della funzione main(). Un'istanza di una 'colomba' viene creata e assegnata a 'b' utilizzando l'assegnazione b = d. Poiché 'dove' implementa tutti i metodi dell'interfaccia 'birds', questa assegnazione è valida.
Quindi, i metodi breath() e fly() vengono chiamati su “b” che è di tipo “birds”. Analogamente, una variabile “a” di tipo “avians” viene dichiarata e assegnata con l'istanza “colomba” di “d”. Poiché 'dove' implementa il metodo feed() definito nell'interfaccia 'avians', anche questa assegnazione è valida. Il metodo feed() viene richiamato su “a” che è di tipo “avians”. Poiché 'a' contiene l'istanza 'colomba', viene eseguito il metodo feed() implementato da 'colomba'.
L'output mostra che i metodi delle interfacce vengono eseguiti correttamente:
Conclusione
Abbiamo appreso le basi delle interfacce Go e fornito esempi pratici per illustrarne l'utilizzo. Definendo le interfacce e implementandole con tipi diversi, possiamo creare programmi flessibili ed estensibili.