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 das interfaces é armazenar diferentes tipos na mesma coleção. Uma fatia de um tipo de interface pode conter qualquer valor que satisfaça essa interface, permitindo agrupar tipos relacionados, mas diferentes.

Considere um cenário em que você precisa gerenciar várias formas. Em vez de usar slices separadas para cada tipo, você pode usar uma única slice do tipo de 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())
    }
}

A fatia shapes contém círculos e 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 uniformemente com todos os tipos de formas.

Coleções polimórficas são essenciais ao criar sistemas que processam itens variados: um sistema de notificações que envia e-mails e mensagens SMS, um jogo que atualiza diferentes tipos de inimigos ou um processador de documentos que lida com vários formatos de arquivo. A coleção não se importa com tipos específicos: apenas que cada elemento forneça o comportamento necessário.

Desafio

Fácil

Vamos criar 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 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 exige um método Summary() string. Essa interface será o contrato comum que todos os tipos de tarefas deverão cumprir.
types.go: Crie três tipos diferentes de tarefas que implementem 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 aceite um slice de Task e imprima o resumo de cada tarefa em sua própria linha. Leia os detalhes das tarefas da entrada, crie uma tarefa de cada tipo, reúna todas em um único slice []Task e passe-o para PrintBacklog.

As seguintes entradas serão fornecidas:

Linha 1: ID do bug
Linha 2: severidade do bug
Linha 3: nome da feature
Linha 4: pontos da feature (inteiro)
Linha 5: tópico da documentação

Por exemplo, dadas as entradas 1042, critical, Dark Mode, 8 e API Reference, sua saída deverá ser:

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

O poder disso está no fato de que PrintBacklog não precisa de lógica separada para bugs, features ou documentação. Ela simplesmente percorre o 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 tipos diversos de maneira uniforme.

Experimente você mesmo

package main

import (
	"fmt"
)

// TODO: Crie uma função PrintBacklog que aceita um slice de Task
// e imprime o resumo de cada task 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 task (BugFix, Feature, Documentation)

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

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