Entendendo Interfaces em Go
Interfaces em Go são um dos conceitos mais poderosos e elegantes da linguagem. Diferente de muitas linguagens orientadas a objetos, Go não utiliza herança de classes. Em vez disso, usa composição e interfaces para criar código flexível e desacoplado. Uma interface é um contrato que define um conjunto de métodos que um tipo deve implementar. Se um tipo implementa todos os métodos da interface, ele satisfaz automaticamente aquela interface — sem necessidade de declaração explícita. Essa abordagem, chamada de "implementação implícita", reduz acoplamento e torna o código mais testável e manutenível.
Para compreender interfaces em Go, você precisa abandonar o pensamento tradicional de linguagens como Java ou C#, onde você declara explicitamente que uma classe implementa uma interface. Em Go, não há essa palavra-chave. Se caminha como um pato, nada como um pato e grasna como um pato, então é um pato — isso é polimorfismo em Go.
Definição e Sintaxe de Interfaces
Declarando uma Interface
Uma interface em Go é declarada usando a palavra-chave type seguida do nome e a palavra-chave interface. Dentro das chaves, você lista as assinaturas dos métodos que devem ser implementados.
package main
type Veiculo interface {
Acelerar()
Frear()
Velocidade() int
}
Essa interface Veiculo define que qualquer tipo que quiser ser um Veiculo deve implementar três métodos: Acelerar(), Frear() e Velocidade() que retorna um int. Note que não há corpo dos métodos na definição da interface — apenas as assinaturas.
Regras Importantes sobre Interfaces
Interfaces em Go podem conter apenas assinaturas de métodos. Elas não podem ter campos de dados ou constantes. Uma interface pode também estar vazia (interface{}), o que significa que qualquer tipo implementa essa interface — útil para código genérico. As interfaces também podem embutir outras interfaces, criando composição de contratos.
package main
type Animal interface {
Fazer_Som()
}
type Terrestre interface {
Animal
Caminhar()
}
Aqui, Terrestre herda implicitamente o método Fazer_Som de Animal, além de exigir Caminhar(). Um tipo que implementa Terrestre precisa implementar ambos os métodos.
Implementação Implícita: Satisfazendo Interfaces
Como Funciona a Satisfação Implícita
Um tipo satisfaz uma interface simplesmente implementando todos os seus métodos. Não é necessário escrever implements Veiculo ou qualquer coisa parecida. Go verifica automaticamente se um tipo possui todos os métodos requeridos.
package main
import "fmt"
type Veiculo interface {
Acelerar()
Frear()
Velocidade() int
}
type Carro struct {
velocidadeAtual int
}
// Implementar o método Acelerar
func (c *Carro) Acelerar() {
c.velocidadeAtual += 20
fmt.Println("Carro acelerou! Velocidade:", c.velocidadeAtual)
}
// Implementar o método Frear
func (c *Carro) Frear() {
c.velocidadeAtual -= 10
if c.velocidadeAtual < 0 {
c.velocidadeAtual = 0
}
fmt.Println("Carro freou! Velocidade:", c.velocidadeAtual)
}
// Implementar o método Velocidade
func (c *Carro) Velocidade() int {
return c.velocidadeAtual
}
type Bicicleta struct {
velocidadeAtual int
}
func (b *Bicicleta) Acelerar() {
b.velocidadeAtual += 5
fmt.Println("Bicicleta acelerou! Velocidade:", b.velocidadeAtual)
}
func (b *Bicicleta) Frear() {
b.velocidadeAtual -= 2
if b.velocidadeAtual < 0 {
b.velocidadeAtual = 0
}
fmt.Println("Bicicleta freou! Velocidade:", b.velocidadeAtual)
}
func (b *Bicicleta) Velocidade() int {
return b.velocidadeAtual
}
func main() {
var v Veiculo
// Carro implementa Veiculo
carro := &Carro{}
v = carro
v.Acelerar()
v.Frear()
fmt.Println("Velocidade do carro:", v.Velocidade())
// Bicicleta também implementa Veiculo
bicicleta := &Bicicleta{}
v = bicicleta
v.Acelerar()
v.Frear()
fmt.Println("Velocidade da bicicleta:", v.Velocidade())
}
Note que nem Carro nem Bicicleta declaram explicitamente que implementam Veiculo. Ambos são automaticamente considerados Veiculo porque possuem todos os métodos requeridos. Isso é a beleza da implementação implícita — você pode escrever código que trabalha com a interface Veiculo sem saber de antemão quais tipos concretos a implementarão.
Recebedores de Método e Interfaces
Um detalhe crucial: ao implementar métodos de uma interface, o tipo do recebedor importa. Se a interface exigir métodos com recebedor de ponteiro (como func (c *Carro) Acelerar()), você não pode usar um recebedor de valor (func (c Carro) Acelerar()). Go verifica isso rigorosamente.
type Imprimivel interface {
Imprimir()
}
type Documento struct {
conteudo string
}
// CORRETO: recebedor de ponteiro
func (d *Documento) Imprimir() {
fmt.Println(d.conteudo)
}
// Agora Documento satisfaz Imprimivel
var doc Imprimivel = &Documento{conteudo: "Hello"}
doc.Imprimir() // Funciona
Polimorfismo em Go
O que é Polimorfismo e Como Go o Implementa
Polimorfismo é a capacidade de um objeto responder a mensagens de diferentes formas. Em Go, polimorfismo é alcançado através de interfaces. Você escreve código genérico que trabalha com uma interface, e em tempo de execução, a implementação concreta é determinada pelo tipo real do objeto. Isso é chamado de "polimorfismo de tempo de execução" ou "dispatch dinâmico".
package main
import "fmt"
type Pagador interface {
Pagar(valor float64)
}
type CartaoCredito struct {
numero string
}
func (c *CartaoCredito) Pagar(valor float64) {
fmt.Printf("Pagamento de R$ %.2f processado com cartão %s\n", valor, c.numero)
}
type PayPal struct {
email string
}
func (p *PayPal) Pagar(valor float64) {
fmt.Printf("Pagamento de R$ %.2f enviado para PayPal (%s)\n", valor, p.email)
}
type Criptomoeda struct {
carteira string
}
func (k *Criptomoeda) Pagar(valor float64) {
fmt.Printf("Pagamento de R$ %.2f realizado em blockchain (%s)\n", valor, k.carteira)
}
// Função polimórfica: aceita qualquer Pagador
func ProcessarPagamento(pagador Pagador, valor float64) {
pagador.Pagar(valor)
}
func main() {
// Mesmo código, diferentes comportamentos
cartao := &CartaoCredito{numero: "1234-5678-9012-3456"}
paypal := &PayPal{email: "user@example.com"}
crypto := &Criptomoeda{carteira: "0x123abc"}
ProcessarPagamento(cartao, 100.00)
ProcessarPagamento(paypal, 50.00)
ProcessarPagamento(crypto, 75.50)
}
Saída esperada:
Pagamento de R$ 100.00 processado com cartão 1234-5678-9012-3456
Pagamento de R$ 50.00 enviado para PayPal (user@example.com)
Pagamento de R$ 75.50 realizado em blockchain (0x123abc)
Type Assertion e Type Switch
Às vezes você precisa descobrir qual tipo concreto está por trás de uma interface. Go fornece type assertion para isso. Uma type assertion permite acessar o valor concreto de uma interface e verificar seu tipo.
package main
import "fmt"
type Animal interface {
Som() string
}
type Cachorro struct{}
func (c *Cachorro) Som() string {
return "Au au"
}
type Gato struct{}
func (g *Gato) Som() string {
return "Miau"
}
func DescreverAnimal(a Animal) {
// Type assertion básica
if cachorro, ok := a.(*Cachorro); ok {
fmt.Println("É um cachorro:", cachorro.Som())
}
// Type switch para múltiplos tipos
switch animal := a.(type) {
case *Cachorro:
fmt.Println("Cachorro fazendo:", animal.Som())
case *Gato:
fmt.Println("Gato fazendo:", animal.Som())
default:
fmt.Println("Animal desconhecido:", a.Som())
}
}
func main() {
DescreverAnimal(&Cachorro{})
DescreverAnimal(&Gato{})
}
A sintaxe a.(*Cachorro) tenta converter a interface para um ponteiro de Cachorro. Se bem-sucedida, retorna o valor e true; caso contrário, retorna nil e false. O type switch é similar a um switch tradicional, mas funciona com tipos em vez de valores.
Polimorfismo com Interface Vazia
A interface vazia interface{} é implementada por todos os tipos. Ela é útil quando você precisa trabalhar com valores de qualquer tipo, como em funções genéricas.
package main
import "fmt"
func Imprimir(valores ...interface{}) {
for _, v := range valores {
fmt.Println(v)
}
}
func ExtrairInfo(valor interface{}) {
switch v := valor.(type) {
case int:
fmt.Printf("Inteiro: %d\n", v)
case string:
fmt.Printf("String: %s\n", v)
case bool:
fmt.Printf("Booleano: %v\n", v)
default:
fmt.Printf("Tipo desconhecido: %T\n", v)
}
}
func main() {
Imprimir(42, "Hello", true, 3.14)
ExtrairInfo(100)
ExtrairInfo("Go é incrível")
}
Use interface{} com cuidado, pois reduz a segurança de tipos. Go é uma linguagem tipada, e abrir mão disso frequentemente leva a código frágil.
Casos de Uso Práticos e Boas Práticas
Exemplo: Sistema de Logging
Um caso de uso clássico de interfaces e polimorfismo é um sistema de logging extensível. Você define uma interface Logger e múltiplas implementações, permitindo trocar o mecanismo de logging sem alterar o código cliente.
package main
import (
"fmt"
"log"
"os"
)
type Logger interface {
Info(mensagem string)
Erro(mensagem string)
Debug(mensagem string)
}
type LoggerConsole struct{}
func (l *LoggerConsole) Info(mensagem string) {
fmt.Println("[INFO]", mensagem)
}
func (l *LoggerConsole) Erro(mensagem string) {
fmt.Println("[ERRO]", mensagem)
}
func (l *LoggerConsole) Debug(mensagem string) {
fmt.Println("[DEBUG]", mensagem)
}
type LoggerArquivo struct {
arquivo *os.File
}
func NovoLoggerArquivo(caminho string) (*LoggerArquivo, error) {
arquivo, err := os.OpenFile(caminho, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
if err != nil {
return nil, err
}
return &LoggerArquivo{arquivo: arquivo}, nil
}
func (l *LoggerArquivo) Info(mensagem string) {
l.arquivo.WriteString("[INFO] " + mensagem + "\n")
}
func (l *LoggerArquivo) Erro(mensagem string) {
l.arquivo.WriteString("[ERRO] " + mensagem + "\n")
}
func (l *LoggerArquivo) Debug(mensagem string) {
l.arquivo.WriteString("[DEBUG] " + mensagem + "\n")
}
// Função que usa Logger sem saber qual implementação é
func ProcessarDados(logger Logger, dados string) {
logger.Info("Iniciando processamento de: " + dados)
logger.Debug("Processando detalhes...")
logger.Info("Processamento concluído")
}
func main() {
// Usando LoggerConsole
console := &LoggerConsole{}
ProcessarDados(console, "arquivo.txt")
// Usando LoggerArquivo
arquivo, err := NovoLoggerArquivo("log.txt")
if err != nil {
log.Fatal(err)
}
ProcessarDados(arquivo, "dados.csv")
}
Boas Práticas
1. Defina interfaces pequenas e focadas. Não crie interfaces gigantescas com muitos métodos. A interface io.Writer tem apenas um método — Write() — e é uma das mais úteis da stdlib.
2. Aceite interfaces, retorne tipos concretos. Quando uma função recebe um parâmetro, peça uma interface para máxima flexibilidade. Quando retorna, retorne um tipo concreto para clareza.
3. Comumente, você não precisa de muitas interfaces. Ao contrário de linguagens como Java, Go incentiva simplicidade. Crie interfaces quando necessário para desacoplamento e testabilidade, não por princípio.
4. Use composição de interfaces. Combine interfaces menores para criar contratos maiores, em vez de criar uma interface monolítica.
type Reader interface {
Read(p []byte) (n int, err error)
}
type Writer interface {
Write(p []byte) (n int, err error)
}
type ReadWriter interface {
Reader
Writer
}