Composição em vez de herança
Conheça a filosofia de design de Go
Composição em vez de herança é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.
Filosofia de projeto do Go
Go omite deliberadamente a herança de classes. A abordagem idiomática é a composição: crie comportamentos combinando tipos e interfaces pequenos.
Por que não usar herança
Árvores de herança profundas são frágeis: uma alteração em uma classe base se propaga de maneira imprevisível. A composição mantém os relacionamentos explícitos e flexíveis.
Possui em vez de É
Em vez de dizer que "um Gerente é um Funcionário", modele "um Gerente possui os dados e as capacidades de um Funcionário" por meio de incorporação ou campos.
package main
import "fmt"
type Employee struct{ Name string }
func (e Employee) Work() string { return e.Name + " works" }
type Manager struct {
Employee
Reports int
}
func main() {
m := Manager{Employee{"Lin"}, 3}
fmt.Println(m.Work(), "-", m.Reports, "reports")
}Programe para interfaces
Defina o comportamento com interfaces pequenas e aceite-as em seguida. As implementações são intercambiáveis e fáceis de substituir ou simular.
package main
import "fmt"
type Notifier interface{ Notify(msg string) }
type Email struct{}
func (Email) Notify(msg string) { fmt.Println("email:", msg) }
func alert(n Notifier, m string) { n.Notify(m) }
func main() {
alert(Email{}, "deploy done")
}Trocando implementações
Como a função depende de uma interface, você pode passar qualquer implementação sem alterar a função.
package main
import "fmt"
type Notifier interface{ Notify(msg string) }
type Email struct{}
type SMS struct{}
func (Email) Notify(m string) { fmt.Println("email:", m) }
func (SMS) Notify(m string) { fmt.Println("sms:", m) }
func alert(n Notifier, m string) { n.Notify(m) }
func main() {
alert(Email{}, "hi")
alert(SMS{}, "hi")
}Combinando comportamentos
Incorpore vários componentes pequenos para montar um tipo repleto de recursos a partir de partes independentes e testáveis.
package main
import "fmt"
type Logger struct{}
func (Logger) Log(s string) { fmt.Println("log:", s) }
type Cache struct{ data map[string]string }
func (c Cache) Get(k string) string { return c.data[k] }
type Service struct {
Logger
Cache
}
func main() {
s := Service{Cache: Cache{data: map[string]string{"k": "v"}}}
s.Log("started")
fmt.Println(s.Get("k"))
}Injeção de dependências
Passe as dependências, como interfaces, para os construtores em vez de defini-las diretamente no código. Isso é composição aplicada à conexão dos componentes.
package main
import "fmt"
type Store interface{ Save(s string) }
type MemStore struct{ items []string }
func (m *MemStore) Save(s string) { m.items = append(m.items, s) }
type App struct{ store Store }
func NewApp(s Store) *App { return &App{store: s} }
func main() {
app := NewApp(&MemStore{})
app.store.Save("x")
fmt.Println("saved")
}Interfaces pequenas vencem
Quanto menor uma interface, mais tipos a satisfazem e mais fácil é testá-la. Quanto maior a interface, mais fraca é a abstração.
Evitando a classe base frágil
Sem herança, não há uma classe base que possa ser quebrada. Cada parte composta evolui de forma independente, reduzindo o acoplamento.
Aceite interfaces, retorne estruturas
Uma orientação comum em Go: as funções aceitam interfaces, que oferecem entradas flexíveis, e retornam estruturas concretas, que oferecem saídas claras e utilizáveis.
Lista de verificação da composição
- Modele possui, não é
- Incorpore componentes pequenos
- Dependa de interfaces pequenas
- Injete dependências
Verificação rápida
Teste seus conhecimentos sobre a filosofia da composição.
Recapitulação
Você aprendeu a filosofia de composição do Go.
- Não há herança; componha com incorporação e interfaces
- Modele possui em vez de é
- Programe para interfaces pequenas e injete dependências
- Aceite interfaces e retorne estruturas
Aprenda Go com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 51
- Aulas
- 203
Perguntas Frequentes
A aula “Composição em vez de herança” é grátis?
Sim — o texto completo de “Composição em vez de herança” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.
O que vou aprender em “Composição em vez de herança”?
Conheça a filosofia de design de Go Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Go Academy?
Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.
Quanto tempo leva a aula “Composição em vez de herança”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Go Academy?
Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Incorporação de structs
- Incorporação de interfaces
- Promoção de métodos
- Composição em vez de herança