Definindo e implementando interfaces
Implementação implícita e a interface vazia
Definindo e implementando interfaces é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 1 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.
O Que É uma Interface?
Uma interface em Go é um conjunto de assinaturas de métodos. Qualquer tipo que implemente todos esses métodos implicitamente satisfaz a interface — não é necessária uma palavra-chave implements. Isso é chamado de tipagem estrutural ou tipagem pato.
Declarando uma Interface
Defina uma interface com a palavra-chave type:
package main
import "fmt"
type Shape interface {
Area() float64
Perimeter() float64
}
type Circle struct{ Radius float64 }
func (c Circle) Area() float64 { return 3.14159 * c.Radius * c.Radius }
func (c Circle) Perimeter() float64 { return 2 * 3.14159 * c.Radius }
func main() {
var s Shape = Circle{5}
fmt.Printf("Area: %.2f\n", s.Area())
}Satisfação Implícita
Não é necessária nenhuma declaração de intenção. Se um tipo tiver os métodos corretos, ele satisfará a interface automaticamente:
package main
import "fmt"
type Greeter interface{ Greet() string }
type English struct{}
func (e English) Greet() string { return "Hello" }
type Spanish struct{}
func (s Spanish) Greet() string { return "Hola" }
func say(g Greeter) { fmt.Println(g.Greet()) }
func main() {
say(English{})
say(Spanish{})
}A Interface Vazia
interface{} (ou any no Go 1.18+) é satisfeita por todos os tipos. Ela é usada quando o tipo é desconhecido em tempo de compilação:
package main
import "fmt"
func printAny(v any) { fmt.Printf("%T: %v\n", v, v) }
func main() {
printAny(42)
printAny("hello")
printAny([]int{1,2,3})
}Valores de Interface
Um valor de interface contém duas coisas: um tipo concreto e um valor concreto. Uma interface nil tem ambos definidos como nil:
package main
import "fmt"
type Animal interface{ Sound() string }
type Dog struct{}
func (d Dog) Sound() string { return "woof" }
func main() {
var a Animal
fmt.Println(a == nil) // true
a = Dog{}
fmt.Println(a == nil) // false
fmt.Println(a.Sound())
}Satisfação de Várias Interfaces
Um tipo pode satisfazer várias interfaces simultaneamente:
package main
import "fmt"
type Reader interface{ Read() string }
type Writer interface{ Write(string) }
type ReadWriter interface{ Reader; Writer }
type File struct{ content string }
func (f *File) Read() string { return f.content }
func (f *File) Write(s string) { f.content = s }
func main() {
var rw ReadWriter = &File{}
rw.Write("hello")
fmt.Println(rw.Read())
}Atribuição de Interfaces
Uma interface mais abrangente pode conter um valor concreto de uma interface mais restrita. A atribuição entre tipos de interface exige que o tipo concreto satisfaça ambas:
package main
import "fmt"
type Stringer interface{ String() string }
type Point struct{ X, Y int }
func (p Point) String() string { return fmt.Sprintf("(%d,%d)", p.X, p.Y) }
func main() {
var s Stringer = Point{3, 4}
fmt.Println(s.String())
}Armadilha da Interface Nil
Uma interface não nil que contém um valor concreto nil NÃO é igual a nil:
package main
import "fmt"
type MyErr struct{}
func (e *MyErr) Error() string { return "oops" }
func bad() error {
var e *MyErr // nil pointer
return e // returns non-nil interface!
}
func main() {
err := bad()
fmt.Println(err == nil) // false — common gotcha
}Interfaces Permitem Testabilidade
Definir dependências como interfaces permite trocar implementações reais por simulações nos testes:
package main
import "fmt"
type EmailSender interface{ Send(to, body string) error }
type MockSender struct{ Sent []string }
func (m *MockSender) Send(to, body string) error {
m.Sent = append(m.Sent, to)
return nil
}
func notify(s EmailSender, addr string) { s.Send(addr, "hello") }
func main() {
mock := &MockSender{}
notify(mock, "a@b.com")
fmt.Println(mock.Sent) // [a@b.com]
}Aceite Interfaces, Retorne Estruturas
Uma boa prática de Go: os parâmetros das funções devem ser interfaces (para oferecer flexibilidade), enquanto os tipos retornados devem ser tipos concretos (para que os chamadores saibam o que receberão):
package main
type Logger interface{ Log(string) }
type FileLogger struct{}
func (f *FileLogger) Log(s string) {}
func NewFileLogger() *FileLogger { // returns concrete
return &FileLogger{}
}
func process(l Logger) {} // accepts interface
func main() { process(NewFileLogger()) }Mantenha as Interfaces Pequenas
A biblioteca padrão do Go favorece interfaces mínimas: io.Reader tem um método, e io.Writer tem um método. Interfaces pequenas são mais fáceis de combinar e simular.
Verificação Rápida
Um tipo precisa declarar que implementa uma interface?
Recapitulação: Interfaces
Principais conclusões:
- Interfaces definem comportamento, não dados
- A satisfação é implícita — não há palavra-chave
implements - A interface vazia (
any) aceita todos os tipos - Tenha cuidado com a armadilha da interface nil
- Mantenha as interfaces pequenas e focadas
Proposta de Prática
Defina uma interface Storage com Save(key, value string) error e Load(key string) (string, error). Implemente-a com um MemStorage respaldado por um mapa e faça um teste.
Perguntas Frequentes
A aula “Definindo e implementando interfaces” é grátis?
Sim — o texto completo de “Definindo e implementando interfaces” é 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 “Definindo e implementando interfaces”?
Implementação implícita e a interface vazia 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 1 de 4.
Quanto tempo leva a aula “Definindo e implementando interfaces”?
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
- Definindo e implementando interfaces
- Interfaces essenciais da biblioteca padrão
- Asserções de tipo e switches de tipo
- Composição de interfaces e boas práticas