Cum funcționează interfețele în Go?

Question

Accepted Answer

O **interfață** Go definește un set de semnături de metode — un contract de comportament. Crucial, interfețele sunt satisfăcute **implicit**: orice tip care are acele metode satisface automat interfața, **fără nicio declarație explicită "implements"**. Această abordare structurală, de tip duck-typing, este distinctivă și puternică.

## Definirea și implementarea implicită a unei interfețe

```go
// define an interface — a set of method signatures
type Speaker interface {
    Speak() string
}

type Dog struct{}
func (d Dog) Speak() string { return "Woof" }   // Dog has Speak() → it IS a Speaker

type Cat struct{}
func (c Cat) Speak() string { return "Meow" }   // Cat too — implicitly

// NO "implements Speaker" anywhere — satisfaction is automatic
var s Speaker = Dog{}    // works because Dog has the Speak() method
s.Speak()                // "Woof"
```

Nu există cuvântul cheie `implements` — dacă un tip are toate metodele interfaței, o satisface automat. Aceasta decuplează interfața de implementările ei (implementatorul nici măcar nu trebuie să știe că interfața există).

## Polimorfismul prin interfețe

```go
func announce(s Speaker) {        // accepts ANY type that has Speak()
    fmt.Println(s.Speak())
}
announce(Dog{})    // "Woof"
announce(Cat{})    // "Meow"

speakers := []Speaker{Dog{}, Cat{}}   // a slice of different types via the interface
for _, sp := range speakers { sp.Speak() }
```

Interfețele permit polimorfismul — scrieți cod împotriva comportamentului, și orice tip conform funcționează.

## Interfața goală și `any`

```go
var x interface{}     // the empty interface — satisfied by EVERY type (no methods required)
x = 42
x = "hello"
// Go 1.18+: `any` is an alias for interface{}
func print(v any) { fmt.Println(v) }   // accepts anything
```

Interfața goală (`interface{}` / `any`) conține orice valoare — folosită atunci când tipul nu este cunoscut dinainte (deși generics înlocuiesc acum adesea aceasta).

## Interfețele din biblioteca standard pe care le veți folosi constant

```go
type Stringer interface { String() string }   // controls fmt printing
type error interface { Error() string }        // the error type itself!
type io.Reader interface { Read(p []byte) (n int, err error) }
type io.Writer interface { Write(p []byte) (n int, err error) }
```

Multa din biblioteca standard este construită pe interfețe mici (`io.Reader`/`io.Writer`, `error`, `Stringer`) — implementarea lor face ca tipurile voastre să funcționeze cu întregul ecosistem.

## Idiomul: acceptați interfețe, returnați struct-uri

```text
Go favors SMALL interfaces (often one method) defined where they're USED (the consumer),
not where types are defined. "The bigger the interface, the weaker the abstraction."
```

## De ce este important

Interfețele sunt centrale în designul Go și în abordarea acestuia a abstractizării și polimorfismului — și satisfacția lor **implicită** (fără cuvântul cheie `implements`; tipizare structurală) este una dintre cele mai distinctive și puternice caracteristici ale limbajului.

Această decuplare înseamnă că tipurile și interfețele evoluează independent, puteți defini interfețe *după* tipurile care le satisfac, și orice tip conform se conectează automat la codul bazat pe interfețe — permițând design-uri flexibile, cu cuplare slabă și testare ușoară (înlocuiți cu implementări mock).

Înțelegerea implementării implicite, polimorfismului prin interfețe, interfața goală/`any`, idiomul interfețelor mici ("acceptați interfețe, returnați struct-uri"), și interfețele omniprezente din biblioteca standard (`error`, `io.Reader`/`Writer`, `Stringer`) este esențială pentru Go idiomativ.

Este un subiect frecvent de interviu tocmai pentru că modelul implicit, structural diferă atât de fundamental de interfețele explicite din Java/C#.

Definirea și implementarea implicită a unei interfețe

Polimorfismul prin interfețe

Interfața goală și any

Interfețele din biblioteca standard pe care le veți folosi constant

Idiomul: acceptați interfețe, returnați struct-uri

De ce este important

Interfața goală și `any`