În Golang, interfețele sunt un concept fundamental și puternic care permite definirea unor contracte abstracte pe care tipurile concrete trebuie să le respecte. Interfețele definesc un set de metode, fără a specifica cum ar trebui implementate aceste metode. Orice tip care implementează toate metodele unei interfețe este considerat implicit că respectă acea interfață.

Caracteristici cheie ale interfețelor în Go:

1. Definirea abstractă a comportamentului - Interfețele nu au implementări, ele doar specifică metodele pe care un tip trebuie să le aibă.
2. Implementare implicită - Un tip implementează o interfață dacă definește metodele interfeței, fără a fi necesară o declarație explicită.
3. Polimorfism - Interfețele permit funcțiilor să accepte parametri de orice tip care implementează interfața, facilitând astfel polimorfismul.

Sintaxă

Interfețele sunt definite folosind cuvântul cheie interface, urmat de un set de semnături de metode. Iată un exemplu simplu:

type Animal interface {
    Speak() string
}

În acest exemplu, orice tip care implementează metoda Speak() string este considerat un Animal.

Practică

Vom crea o aplicație simplă pentru a demonstra utilizarea interfețelor în Go.

1. Definirea interfeței

Să definim o interfață Animal care are o metodă Speak():

package main

import "fmt"

type Animal interface {
    Speak() string
}

package main- Specifică faptul că acest fișier aparține pachetului principal. Programul începe execuția din funcția main a acestui pachet.

import "fmt" - Importă pachetul fmt, care furnizează funcții pentru formatarea intrărilor și ieșirilor, cum ar fi Println.

type Animal interface { Speak() string } - Definim o interfață numită Animal. Aceasta specifică faptul că orice tip care implementează metoda Speak (care nu primește niciun parametru și returnează un string) respectă interfața Animal.

2. Implementarea interfeței

Vom crea două structuri Dog și Cat care implementează interfața Animal.

type Dog struct {
    Name string
}

func (d Dog) Speak() string {
    return "Woof!"
}

type Cat struct {
    Name string
}

func (c Cat) Speak() string {
    return "Meow!"
}

type Dog struct { Name string } - Definim o structură Dog cu un singur câmp Name de tip string.

type Cat struct { Name string } - Definim o structură Cat cu un singur câmp Name de tip string.

func (d Dog) Speak() string - Definim o metodă Speak pentru tipul Dog. Aceasta respectă semnătura definită în interfața Animal (nu primește parametri și returnează un string).

return "Woof!" - Metoda returnează Woof!, sunetul specific unui câine.

3. Utilizarea interfeței

func main() {
    var animals []Animal

    animals = append(animals, Dog{Name: "Buddy"})
    animals = append(animals, Cat{Name: "Whiskers"})

    for _, animal := range animals {
        fmt.Println(animal.Speak())
    }
}

func main() - Definim funcția main, punctul de intrare al programului.

var animals []Animal - Declarăm un slice de interfețe Animal numit animals. Un slice este o colecție dinamică de elemente de același tip, în acest caz elemente de tip Animal.

append(animals, Dog{Name: "Buddy"}) - Adăugăm un element de tip Dog în slice-ul animals. Observați că instanțiem structura Dog cu un câmp Name având valoarea "Buddy".

append(animals, Cat{Name: "Whiskers"}) - Adăugăm un element de tip Cat în slice-ul animals. Instanțiem structura Cat cu un câmp Name având valoarea "Whiskers".

for _, animal := range animals - Utilizăm un loop for pentru a itera prin fiecare element din slice-ul animals. range returnează indexul și valoarea elementului, dar în acest caz ignorăm indexul folosind _.

fmt.Println(animal.Speak()) - Pentru fiecare animal din slice, apelăm metoda Speak și afișăm rezultatul folosind fmt.Println.

Interfețele în Go sunt esențiale pentru a crea cod modular și flexibil. Ele permit definirea unor comportamente abstracte pe care tipurile concrete trebuie să le implementeze, facilitând astfel polimorfismul și separarea clară a responsabilităților. Practicile bune de programare în Go includ utilizarea interfețelor pentru a defini contracte între diferite părți ale aplicației.