Coleções Polimórficas

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

Uma das aplicações mais poderosas de interfaces é armazenar diferentes tipos na mesma coleção. Um slice de um tipo de interface pode conter qualquer valor que satisfaça essa interface, permitindo que você agrupe tipos relacionados, mas diferentes.

Considere um cenário em que você precisa gerenciar várias formas. Em vez de slices separados para cada tipo, você pode usar um único slice do tipo interface:

type Shape interface {
    Area() float64
}

type Circle struct{ Radius float64 }
func (c Circle) Area() float64 { return 3.14159 * c.Radius * c.Radius }

type Rectangle struct{ Width, Height float64 }
func (r Rectangle) Area() float64 { return r.Width * r.Height }

func main() {
    shapes := []Shape{
        Circle{Radius: 5},
        Rectangle{Width: 4, Height: 3},
        Circle{Radius: 2},
    }
    
    for _, s := range shapes {
        fmt.Printf("Area: %.2f\n", s.Area())
    }
}

O slice shapes contém tanto círculos quanto retângulos. Ao iterar, cada elemento responde a Area() de acordo com seu tipo real. Isso é polimorfismo aplicado a coleções — o mesmo loop lida com todos os tipos de formas uniformemente.

Coleções polimórficas são essenciais ao construir sistemas que processam itens variados: um sistema de notificação enviando e-mails e mensagens SMS, um jogo atualizando diferentes tipos de inimigos ou um processador de documentos lidando com múltiplos formatos de arquivo. A coleção não se importa com tipos específicos — apenas que cada elemento forneça o comportamento exigido.

Desafio

Fácil

Vamos construir um sistema de gerenciamento de tarefas que lida com diferentes tipos de tarefas por meio de uma interface unificada. Você criará vários tipos de tarefas e as processará todas juntas em uma coleção polimórfica.

Você organizará seu código em três arquivos:

task.go: Defina uma interface Task que requer um método Summary() string. Esta interface será o contrato comum que todos os tipos de tarefas devem cumprir.
types.go: Crie três tipos de tarefas diferentes que implementam a interface Task:
- BugFix com os campos ID (string) e Severity (string)—seu Summary() retorna "Bug #[ID] ([Severity])"
- Feature com os campos Name (string) e Points (int)—seu Summary() retorna "Feature: [Name] - [Points] pts"
- Documentation com o campo Topic (string)—seu Summary() retorna "Docs: [Topic]"
main.go: Crie uma função chamada PrintBacklog que aceita um slice de Task e imprime o resumo de cada tarefa em sua própria linha. Leia os detalhes das tarefas da entrada, crie uma de cada tipo de tarefa, colete todas em um único slice []Task e passe-o para PrintBacklog.

As seguintes entradas serão fornecidas:

Linha 1: Bug ID
Linha 2: Bug severity
Linha 3: Feature name
Linha 4: Feature points (inteiro)
Linha 5: Documentation topic

Por exemplo, dados "1042", "critical", "Dark Mode", 8 e "API Reference", sua saída deve ser:

Bug #1042 (critical)
Feature: Dark Mode - 8 pts
Docs: API Reference

O poder aqui é que PrintBacklog não precisa de lógica separada para bugs, features ou documentação—ele simplesmente itera pelo slice e chama Summary() em cada elemento. Cada tipo de tarefa responde com seu próprio formato exclusivo, demonstrando como coleções polimórficas permitem processar diversos tipos de forma uniforme.

Folha de consulta

Um slice de um tipo interface pode conter qualquer valor que satisfaça essa interface, permitindo coleções polimórficas:

type Shape interface {
    Area() float64
}

type Circle struct{ Radius float64 }
func (c Circle) Area() float64 { return 3.14159 * c.Radius * c.Radius }

type Rectangle struct{ Width, Height float64 }
func (r Rectangle) Area() float64 { return r.Width * r.Height }

func main() {
    shapes := []Shape{
        Circle{Radius: 5},
        Rectangle{Width: 4, Height: 3},
        Circle{Radius: 2},
    }
    
    for _, s := range shapes {
        fmt.Printf("Area: %.2f\n", s.Area())
    }
}

O slice shapes contém tipos diferentes (Circle e Rectangle) que implementam a interface Shape. Ao iterar, cada elemento responde a Area() de acordo com seu tipo real — isso é o polimorfismo aplicado a coleções.

Este padrão é útil para processar itens variados de forma uniforme: sistemas de notificação que lidam com diferentes tipos de mensagens, jogos atualizando vários tipos de inimigos ou processadores de documentos que lidam com múltiplos formatos de arquivo.

Experimente você mesmo

package main

import (
	"fmt"
)

// TODO: Crie uma função PrintBacklog que aceite um slice de Task
// e imprima o resumo de cada tarefa em sua própria linha

func main() {
	// Ler entrada
	var bugID string
	var bugSeverity string
	var featureName string
	var featurePoints int
	var docTopic string

	fmt.Scanln(&bugID)
	fmt.Scanln(&bugSeverity)
	fmt.Scanln(&featureName)
	fmt.Scanln(&featurePoints)
	fmt.Scanln(&docTopic)

	// TODO: Crie um de cada tipo de tarefa (BugFix, Feature, Documentation)

	// TODO: Colete todas as tarefas em um único slice []Task

	// TODO: Chame PrintBacklog com o slice de tarefas
}