Hoe werken interfaces in Go?

Question

Accepted Answer

Een Go **interface** definieert een verzameling van methodhandtekeningen — een contract van gedrag. Cruciaal is dat interfaces **impliciet** worden voldaan: elk type dat deze methoden heeft, voldoet automatisch aan de interface, **zonder expliciete "implements" declaratie**. Deze structurele, duck-typing benadering is onderscheidend en krachtig.

## Interfaces definiëren en impliciet implementeren

```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"
```

Er is geen `implements` trefwoord — als een type alle methoden van de interface heeft, voldoet het automatisch aan de interface. Dit ontkoppelt de interface van haar implementaties (de implementeerder hoeft zelfs niet te weten dat de interface bestaat).

## Polymorfisme via interfaces

```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() }
```

Interfaces maken polymorfisme mogelijk — schrijf code tegen het gedrag, en elk conform type werkt.

## De lege interface en `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
```

De lege interface (`interface{}` / `any`) kan elke waarde bevatten — gebruikt wanneer het type niet vooraf bekend is (hoewel generics dit nu vaak vervangen).

## Standard library interfaces die je constant zult gebruiken

```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) }
```

Groot deel van de standard library is gebouwd op kleine interfaces (`io.Reader`/`io.Writer`, `error`, `Stringer`) — ze implementeren maakt je types werk met het hele ecosysteem.

## Het idioom: accepteer interfaces, return structs

```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."
```

## Waarom het belangrijk is

Interfaces zijn centraal in Go's ontwerp en zijn benadering van abstractie en polymorfisme — en hun **impliciete bevrediging** (geen `implements` trefwoord; structurele typing) is een van de meest onderscheidende en krachtige features in de taal.

Deze ontkoppeling betekent dat types en interfaces onafhankelijk evolueren, je interfaces kunt definiëren *nadat* de types die hen bevredigen, en elk conform type sluit automatisch aan op interface-gebaseerde code — waardoor flexibele, losjes gekoppelde ontwerpen en gemakkelijk testen mogelijk worden (swap in mock-implementaties).

Inzicht in impliciete implementatie, polymorfisme via interfaces, de lege interface/`any`, het klein-interface idioom ("accepteer interfaces, return structs"), en de alomtegenwoordige standard-library interfaces (`error`, `io.Reader`/`Writer`, `Stringer`) is essentieel voor idiomatische Go.

Het is een frequent interviewonderwerp precies omdat het impliciete, structurele model zich fundamenteel verschilt van de expliciete interfaces van Java/C#.

Interfaces definiëren en impliciet implementeren

Polymorfisme via interfaces

De lege interface en any

Standard library interfaces die je constant zult gebruiken

Het idioom: accepteer interfaces, return structs

Waarom het belangrijk is

De lege interface en `any`