Polimorfismo via Interfaces

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

O Polimorfismo permite que diferentes tipos sejam tratados de forma uniforme por meio de uma interface compartilhada. Em Go, isso é alcançado inteiramente através de interfaces, sem herança ou hierarquias de classes.

Quando uma função aceita um tipo de interface como parâmetro, qualquer tipo concreto que implemente essa interface pode ser passado. A função não precisa conhecer o tipo específico — ela se preocupa apenas com o comportamento definido pela interface:

type Speaker interface {
    Speak() string
}

type Dog struct{ Name string }
func (d Dog) Speak() string { return "Woof!" }

type Cat struct{ Name string }
func (c Cat) Speak() string { return "Meow!" }

func MakeSound(s Speaker) {
    fmt.Println(s.Speak())
}

Agora o MakeSound funciona com qualquer tipo que tenha um método Speak():

func main() {
    dog := Dog{Name: "Rex"}
    cat := Cat{Name: "Whiskers"}
    
    MakeSound(dog)  // Au au!
    MakeSound(cat)  // Miau!
}

A mesma chamada de função produz comportamentos diferentes dependendo do tipo real passado. Isso é o polimorfismo em ação. A função MakeSound é escrita uma única vez, mas funciona com um número ilimitado de tipos, desde que eles satisfaçam a interface Speaker.

Esta abordagem mantém seu código flexível e extensível. Adicionar um novo tipo que fala não requer alterações nas funções existentes — basta implementar a interface e ela funcionará automaticamente.

Desafio

Fácil

Vamos construir um sistema de descrição de veículos que demonstra o polimorfismo em ação. Você criará diferentes tipos de veículos que compartilham um comportamento comum por meio de uma interface e, em seguida, escreverá uma única função que funciona com qualquer veículo.

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

vehicles.go: Defina uma interface Describer que requer um método Describe() string. Em seguida, crie três tipos de veículos que implementam essa interface à sua maneira:
- Car com os campos Brand e Model—seu Describe() retorna Car: [Brand] [Model]
- Motorcycle com os campos Brand e EngineCC (int)—seu Describe() retorna Motorcycle: [Brand] [EngineCC]cc
- Bicycle com o campo Type (como "Mountain" ou "Road")—seu Describe() retorna Bicycle: [Type]
main.go: Crie uma função chamada PrintDescription que aceita qualquer Describer e imprime o resultado da chamada de Describe(). Leia os detalhes do veículo a partir da entrada, crie um de cada tipo de veículo e passe cada um para PrintDescription para demonstrar que a mesma função funciona com todos os três tipos diferentes.

As seguintes entradas serão fornecidas:

Linha 1: Marca do carro
Linha 2: Modelo do carro
Linha 3: Marca da motocicleta
Linha 4: Cilindrada (CC) do motor da motocicleta (inteiro)
Linha 5: Tipo de bicicleta

Por exemplo, dados Toyota, Camry, Honda, 600, e Mountain, sua saída deve ser:

Car: Toyota Camry
Motorcycle: Honda 600cc
Bicycle: Mountain

Observe como a PrintDescription não precisa saber se está recebendo um Car, Motorcycle ou Bicycle—ela simplesmente chama Describe() e cada tipo responde com sua própria saída exclusiva. Isso é polimorfismo: uma função, múltiplos comportamentos.

Folha de consulta

O polimorfismo permite que diferentes tipos sejam tratados de forma uniforme por meio de uma interface compartilhada. Em Go, isso é alcançado por meio de interfaces sem herança ou hierarquias de classes.

Quando uma função aceita um tipo de interface como parâmetro, qualquer tipo concreto que implemente essa interface pode ser passado:

type Speaker interface {
    Speak() string
}

type Dog struct{ Name string }
func (d Dog) Speak() string { return "Woof!" }

type Cat struct{ Name string }
func (c Cat) Speak() string { return "Meow!" }

func MakeSound(s Speaker) {
    fmt.Println(s.Speak())
}

A mesma função funciona com diferentes tipos:

func main() {
    dog := Dog{Name: "Rex"}
    cat := Cat{Name: "Whiskers"}
    
    MakeSound(dog)  // Woof!
    MakeSound(cat)  // Meow!
}

A função é escrita uma única vez, mas funciona com tipos ilimitados, desde que satisfaçam a interface. Adicionar novos tipos não requer alterações nas funções existentes — basta implementar a interface.

Experimente você mesmo

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

// TODO: Crie uma função chamada PrintDescription que aceite qualquer Describer
// e imprima o resultado da chamada de Describe()

func main() {
	reader := bufio.NewReader(os.Stdin)

	// Lê os detalhes do carro
	carBrand, _ := reader.ReadString('\n')
	carBrand = strings.TrimSpace(carBrand)
	carModel, _ := reader.ReadString('\n')
	carModel = strings.TrimSpace(carModel)

	// Lê os detalhes da motocicleta
	motoBrand, _ := reader.ReadString('\n')
	motoBrand = strings.TrimSpace(motoBrand)
	motoEngineStr, _ := reader.ReadString('\n')
	motoEngineStr = strings.TrimSpace(motoEngineStr)
	motoEngine, _ := strconv.Atoi(motoEngineStr)

	// Lê os detalhes da bicicleta
	bicycleType, _ := reader.ReadString('\n')
	bicycleType = strings.TrimSpace(bicycleType)

	// TODO: Crie um Car, Motorcycle e Bicycle usando os valores de entrada

	// TODO: Chame PrintDescription para cada veículo para demonstrar o polimorfismo
	fmt.Println("TODO: Print vehicle descriptions")
}