Implementação Implícita

Parte da seção Programação Orientada a Objetos do Journey de GO da Coddy — lição 26 de 107.

Em muitas linguagens orientadas a objetos como Java ou C#, você deve declarar explicitamente que um tipo implementa uma interface usando palavras-chave como implements. Go adota uma abordagem diferente: a implementação de interface é implícita.

Um tipo satisfaz uma interface simplesmente ao implementar todos os seus métodos. Não há necessidade de declarar o relacionamento em lugar nenhum. O compilador descobre isso automaticamente.

type Writer interface {
    Write(data string) int
}

type FileWriter struct {
    Filename string
}

// FileWriter implementa implicitamente Writer
func (f FileWriter) Write(data string) int {
    fmt.Println("Writing to", f.Filename)
    return len(data)
}

Observe que não há uma declaração implements Writer no FileWriter. Como o FileWriter possui um método Write(data string) int que corresponde à assinatura da interface, ele satisfaz automaticamente a interface Writer.

Este design tem uma consequência poderosa: você pode definir interfaces depois que os tipos já existem. Se uma biblioteca de terceiros tem um tipo com métodos que você precisa, você pode criar uma interface que ele já satisfaz sem modificar o código original.

func Save(w Writer, content string) {
    w.Write(content)
}

func main() {
    fw := FileWriter{Filename: "data.txt"}
    Save(fw, "Hello!")  // Funciona porque FileWriter satisfaz Writer
}

A implementação implícita mantém o código Go desacoplado e flexível. Os tipos não precisam saber sobre as interfaces antecipadamente, tornando mais fácil compor sistemas a partir de partes independentes.

Desafio

Fácil

Vamos construir um sistema de entrega de mensagens que demonstra como os tipos satisfazem interfaces implicitamente em Go. Você criará diferentes tipos de mensageiros que satisfazem a mesma interface — sem nunca declarar esse relacionamento explicitamente.

Você organizará seu código em dois arquivos:

messengers.go: Defina uma interface Messenger com um único método Send(message string) string. Em seguida, crie duas structs que satisfarão implicitamente esta interface:
- EmailMessenger com um campo Address (string)
- SMSMessenger com um campo PhoneNumber (string)
Cada struct deve ter um método Send que retorna uma string descrevendo a entrega. Nenhuma das structs deve declarar explicitamente que implementa Messenger — o Go descobrirá isso automaticamente com base nas assinaturas dos métodos.
main.go: Crie uma função chamada DeliverMessage que aceita qualquer Messenger e uma string de mensagem, e então retorna o resultado da chamada de Send. Leia as informações de contato da entrada, crie ambos os tipos de mensageiros e use sua função para entregar mensagens através de cada um.

As seguintes entradas serão fornecidas:

Linha 1: Endereço de e-mail
Linha 2: Número de telefone
Linha 3: Mensagem para enviar

Seus métodos Send devem retornar strings nestes formatos:

EmailMessenger: Email to [Address]: [message]
SMSMessenger: SMS to [PhoneNumber]: [message]

Por exemplo, dado alice@example.com, 555-1234, e Hello!, sua saída deve ser:

Email to alice@example.com: Hello!
SMS to 555-1234: Hello!

O ponto principal aqui é que sua função DeliverMessage aceita qualquer Messenger, e tanto EmailMessenger quanto SMSMessenger satisfazem essa interface simplesmente por possuírem um método Send correspondente. Não há a palavra-chave implements em lugar nenhum — a implementação implícita do Go cuida de tudo.

Folha de consulta

Em Go, a implementação de interfaces é implícita. Um tipo satisfaz uma interface simplesmente implementando todos os seus métodos — nenhuma declaração explícita é necessária.

type Writer interface {
    Write(data string) int
}

type FileWriter struct {
    Filename string
}

// FileWriter implementa implicitamente Writer
func (f FileWriter) Write(data string) int {
    fmt.Println("Writing to", f.Filename)
    return len(data)
}

Não há uma declaração implements Writer. Como o FileWriter possui um método Write(data string) int que corresponde à assinatura da interface, ele satisfaz automaticamente a interface Writer.

Você pode usar qualquer tipo que satisfaça uma interface sem que o tipo saiba sobre a interface:

func Save(w Writer, content string) {
    w.Write(content)
}

func main() {
    fw := FileWriter{Filename: "data.txt"}
    Save(fw, "Hello!")  // Funciona porque FileWriter satisfaz Writer
}

Esse design permite que você defina interfaces após os tipos já existirem, tornando o código desacoplado e flexível.

Experimente você mesmo

package main

import (
	"bufio"
	"fmt"
	"os"
)

// TODO: Crie uma função DeliverMessage que aceite qualquer Messenger
// e uma string de mensagem, então retorne o resultado da chamada de Send

func main() {
	reader := bufio.NewReader(os.Stdin)
	
	// Ler endereço de e-mail
	email, _ := reader.ReadString('\n')
	email = email[:len(email)-1]
	
	// Ler número de telefone
	phone, _ := reader.ReadString('\n')
	phone = phone[:len(phone)-1]
	
	// Ler mensagem
	message, _ := reader.ReadString('\n')
	if len(message) > 0 && message[len(message)-1] == '\n' {
		message = message[:len(message)-1]
	}
	
	// TODO: Crie um EmailMessenger com o endereço de e-mail
	
	// TODO: Crie um SMSMessenger com o número de telefone
	
	// TODO: Use DeliverMessage para enviar a mensagem através de cada messenger
	// e imprima os resultados
}