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 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())
    }
}

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 com todos os tipos de formas de maneira uniforme.

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 os 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 tarefa devem cumprir.
types.go: Crie três tipos diferentes de tarefa 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 uma fatia de Task e imprime 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 uma única fatia []Task e passe-a para PrintBacklog.

As seguintes entradas serão fornecidas:

Linha 1: ID do bug
Linha 2: Gravidade do bug
Linha 3: Nome da funcionalidade
Linha 4: Pontos da funcionalidade (inteiro)
Linha 5: Tópico da documentação

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

Bug #1042 (critical)
Feature: Themes - 8 pts
Docs: API

A vantagem aqui é que PrintBacklog não precisa de uma lógica separada para bugs, funcionalidades ou documentação. Ela simplesmente percorre a fatia e chama Summary() em cada elemento. Cada tipo de tarefa responde com seu próprio formato exclusivo, demonstrando como as 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 receba um slice de Task
// e imprima o resumo de cada tarefa em sua própria linha

func main() {
	// Leia a 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 uma tarefa de cada tipo (BugFix, Feature, Documentation)

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

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