Como funciona o embedding de struct (composição)?

Question

Accepted Answer

Go **não possui herança** — em vez disso, usa **composição** via embedding de struct. Ao incorporar uma struct (ou interface) dentro de outra, o tipo externo ganha os campos e métodos do tipo interno diretamente. Esta é a resposta do Go para reutilização de código, favorecendo composição "tem-um" sobre herança "é-um".

## Embedding de uma struct

```go
type Animal struct {
    Name string
}
func (a Animal) Eat() string {
    return a.Name + " is eating"
}

type Dog struct {
    Animal    // EMBEDDED — no field name, just the type → composition
    Breed string
}

d := Dog{
    Animal: Animal{Name: "Rex"},
    Breed:  "Lab",
}

// Dog gets Animal's fields and methods PROMOTED — accessed directly
fmt.Println(d.Name)     // "Rex" — promoted from the embedded Animal
fmt.Println(d.Eat())    // "Rex is eating" — Animal's method, called on Dog
```

Embedding (escrever apenas o nome do tipo, sem nome de campo) **promove** os campos e métodos do tipo incorporado para a struct externa — então `d.Name` e `d.Eat()` funcionam como se pertencessem a `Dog`. Isto parece herança, mas é composição: `Dog` *tem um* `Animal`.

## Sobrescrevendo métodos promovidos

```go
func (d Dog) Eat() string {        // Dog defines its OWN Eat()
    return d.Name + " the dog eats noisily"
}
d.Eat()         // calls Dog's Eat (the outer one shadows the embedded one)
d.Animal.Eat()  // explicitly call the embedded Animal's Eat if needed
```

O tipo externo pode definir um método com o mesmo nome para "sobrescrever" (sombrear) o promovido; você ainda pode alcançar a versão incorporada explicitamente.

## Embedding de interfaces (muito comum)

```go
// embed interfaces to compose larger ones
type Reader interface { Read(p []byte) (int, error) }
type Writer interface { Write(p []byte) (int, error) }

type ReadWriter interface {   // composed from both via embedding
    Reader
    Writer
}
// (this is exactly how io.ReadWriter is defined in the standard library)
```

O embedding de interface compõe pequenas interfaces em interfaces maiores — usado em toda a biblioteca padrão.

## Composição sobre herança — a filosofia Go

```text
No class hierarchies, no "extends". Instead:
  ✓ Embed to reuse fields/methods (has-a)
  ✓ Embed interfaces to compose behavior contracts
  ✓ Avoids the fragility, deep hierarchies, and tight coupling of inheritance
```

## Por que isso importa

O embedding de struct é o mecanismo distintivo do Go para **reutilização e composição de código**, substituindo a herança encontrada na maioria das linguagens OOP.

Compreendê-lo é essencial porque é como Go alcança reutilização (promovendo campos/métodos incorporados para que o tipo externo "herde" comportamento através de composição) enquanto deliberadamente evita os problemas bem conhecidos da herança (classes base frágeis, hierarquias profundas e rígidas, acoplamento apertado).

Ele incorpora o princípio amplamente endossado **"composição sobre herança".** Embedding aparece constantemente — embedding de structs para reutilização, embedding de interfaces para construir contratos maiores (como `io.ReadWriter`), e embedding para comportamento estilo mixin.

Reconhecer que Go não possui herança e que embedding é sua alternativa composicional — além das regras de promoção e sombreamento de métodos — é fundamental para ler e projetar Go idiomático, e um tópico comum de entrevista dada a sua diferença de linguagens baseadas em classes.