Collections polymorphes

Fait partie de la section Programmation Orientée Objet du Journey GO de Coddy. Leçon 44 sur 107.

L’une des applications les plus puissantes des interfaces consiste à stocker différents types dans la même collection. Une tranche d’un type d’interface peut contenir toute valeur qui satisfait cette interface, ce qui vous permet de regrouper des types apparentés, mais différents.

Imaginez un scénario où vous devez gérer différentes formes. Au lieu d’utiliser des slices distincts pour chaque type, vous pouvez utiliser un seul slice du type 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.Width }

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

La tranche shapes contient à la fois des cercles et des rectangles. Lors de l’itération, chaque élément répond à Area() en fonction de son type réel. Il s’agit de polymorphisme appliqué aux collections : la même boucle gère uniformément tous les types de formes.

Les collections polymorphes sont essentielles lors de la création de systèmes qui traitent des éléments variés : un système de notifications envoyant des e-mails et des SMS, un jeu mettant à jour différents types d’ennemis ou un processeur de documents gérant plusieurs formats de fichiers. La collection ne se soucie pas des types spécifiques : elle exige seulement que chaque élément fournisse le comportement requis.

Défi

Facile

Construisons un système de gestion des tâches qui traite différents types de tâches au moyen d’une interface unifiée. Vous créerez différents types de tâches et les traiterez tous ensemble dans une collection polymorphe.

Vous organiserez votre code dans trois fichiers :

task.go : définissez une interface Task qui exige une méthode Summary() string. Cette interface constituera le contrat commun que tous les types de tâches devront respecter.
types.go : créez trois types de tâches différents qui implémentent tous l’interface Task :
- BugFix avec les champs ID (string) et Severity (string). Sa méthode Summary() renvoie Bug #[ID] ([Severity])
- Feature avec les champs Name (string) et Points (int). Sa méthode Summary() renvoie Feature: [Name] - [Points] pts
- Documentation avec le champ Topic (string). Sa méthode Summary() renvoie Docs: [Topic]
main.go : créez une fonction appelée PrintBacklog qui accepte une tranche de Task et affiche le résumé de chaque tâche sur sa propre ligne. Lisez les détails des tâches depuis l’entrée, créez une tâche de chaque type, rassemblez-les dans une seule tranche []Task, puis transmettez-la à PrintBacklog.

Les entrées suivantes seront fournies :

Ligne 1 : ID du bug
Ligne 2 : gravité du bug
Ligne 3 : nom de la fonctionnalité
Ligne 4 : points de la fonctionnalité (entier)
Ligne 5 : sujet de la documentation

Par exemple, avec 1042, critical, Dark Mode, 8 et API Reference, votre sortie devrait être :

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

L’intérêt est que PrintBacklog n’a pas besoin d’une logique distincte pour les bugs, les fonctionnalités ou la documentation. Elle parcourt simplement la tranche et appelle Summary() sur chaque élément. Chaque type de tâche répond avec son propre format unique, illustrant comment les collections polymorphes permettent de traiter uniformément des types variés.

Essayez vous-même

package main

import (
	"fmt"
)

// TODO: Créer une fonction PrintBacklog qui accepte une slice de Task
// et affiche le résumé de chaque tâche sur sa propre ligne

func main() {
	// Lire l'entrée
	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: Créer une de chaque type de tâche (BugFix, Feature, Documentation)

	// TODO: Collecter toutes les tâches dans une seule slice []Task

	// TODO: Appeler PrintBacklog avec la slice de tâches
}