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 une 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.

Considère un scénario dans lequel tu dois gérer différentes formes. Au lieu de créer une tranche distincte pour chaque type, tu peux utiliser une seule tranche 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.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())
    }
}

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. C’est le polymorphisme appliqué aux collections : la même boucle traite uniformément tous les types de formes.

Les collections polymorphes sont essentielles pour créer des systèmes qui traitent des éléments variés : un système de notification qui envoie des courriels et des SMS, un jeu qui met à jour différents types d’ennemis, ou un processeur de documents qui gère 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 prend en charge différents types de tâches au moyen d’une interface unifiée. Tu vas créer différents types de tâches et les traiter ensemble dans une collection polymorphe.

Tu vas répartir ton code dans trois fichiers :

task.go : définis 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ée trois types de tâches différents qui implémentent chacun 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ée une fonction appelée PrintBacklog qui accepte une slice de Task et affiche le résumé de chaque tâche sur sa propre ligne. Lis les détails des tâches depuis l’entrée, crée une tâche de chaque type, rassemble-les dans une seule slice []Task, puis passe-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, Themes, 8 et API, ta sortie devrait être :

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

L’avantage, ici, c’est que PrintBacklog n’a pas besoin d’une logique distincte pour les bugs, les fonctionnalités ou la documentation. La fonction parcourt simplement la slice et appelle Summary() sur chaque élément. Chaque type de tâche renvoie son propre format, ce qui montre 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 un slice de Task
// et affiche le résumé de chaque tâche sur une ligne distincte

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 tâche de chaque type (BugFix, Feature, Documentation)

	// TODO: Rassembler toutes les tâches dans un seul slice []Task

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