Como funcionam interfaces em Go?

Question

Accepted Answer

Uma **interface** em Go define um conjunto de assinaturas de métodos — um contrato de comportamento. Crucialmente, interfaces são satisfeitas **implicitamente**: qualquer tipo que possua esses métodos satisfaz automaticamente a interface, **sem nenhuma declaração explícita "implements"**. Essa abordagem estrutural, do tipo duck-typing, é distintiva e poderosa.

## Definindo e implementando implicitamente uma interface

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

Não há palavra-chave `implements` — se um tipo possui todos os métodos da interface, ele satisfaz a interface automaticamente. Isso desacopla a interface de suas implementações (o implementador nem precisa saber que a interface existe).

## Polimorfismo através de 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 habilitam polimorfismo — escreva código contra o comportamento, e qualquer tipo em conformidade funciona.

## A interface vazia e `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
```

A interface vazia (`interface{}` / `any`) contém qualquer valor — usada quando o tipo não é conhecido antecipadamente (embora genéricos agora frequentemente substituam isso).

## Interfaces da biblioteca padrão que você usará constantemente

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

Muita da biblioteca padrão é construída sobre interfaces pequenas (`io.Reader`/`io.Writer`, `error`, `Stringer`) — implementá-las faz seus tipos funcionarem com todo o ecossistema.

## O idioma: aceite interfaces, retorne 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."
```

## Por que isso importa

Interfaces são centrais ao design do Go e sua abordagem para abstração e polimorfismo — e sua **satisfação implícita** (sem palavra-chave `implements`; tipagem estrutural) é uma das características mais distintivas e poderosas da linguagem.

Esse desacoplamento significa que tipos e interfaces evoluem independentemente, você pode definir interfaces *depois* dos tipos que as satisfazem, e qualquer tipo em conformidade se conecta automaticamente ao código baseado em interfaces — habilitando designs flexíveis, fracamente acoplados e testes fáceis (substitua implementações mock).

Compreender implementação implícita, polimorfismo via interfaces, a interface vazia/`any`, o idioma de interfaces pequenas ("aceite interfaces, retorne structs"), e as interfaces ubíquas da biblioteca padrão (`error`, `io.Reader`/`Writer`, `Stringer`) é essencial para Go idiomático.

É um tópico frequente de entrevista precisamente porque o modelo implícito e estrutural difere tão fundamentalmente das interfaces explícitas de Java/C#.

Definindo e implementando implicitamente uma interface

Polimorfismo através de interfaces

A interface vazia e any

Interfaces da biblioteca padrão que você usará constantemente

O idioma: aceite interfaces, retorne structs

Por que isso importa

A interface vazia e `any`