Composition d’interfaces

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

Go vous permet de créer des interfaces plus grandes en composant des interfaces plus petites. Au lieu de définir une grande interface avec de nombreuses méthodes, vous intégrez des interfaces existantes dans la définition d’une nouvelle interface.

type Reader interface {
    Read() string
}

type Writer interface {
    Write(data string)
}

// ReadWriter combine les deux interfaces
type ReadWriter interface {
    Reader
    Writer
}

L’interface ReadWriter nécessite désormais les méthodes Read() et Write(). Tout type qui implémente ces deux méthodes satisfait ReadWriter, ainsi que Reader et Writer individuellement.

type File struct {
    Name string
}

func (f File) Read() string       { return "file content" }
func (f File) Write(data string)  { fmt.Println("Writing:", data) }

func Process(rw ReadWriter) {
    content := rw.Read()
    rw.Write(content)
}

func main() {
    f := File{Name: "data.txt"}
    Process(f)  // File satisfait ReadWriter
}

Cette approche de composition permet de garder les interfaces petites et ciblées. Vous pouvez les combiner selon vos besoins, créant ainsi des contrats précis pour vos fonctions. La bibliothèque standard de Go utilise largement ce modèle, comme io.ReadWriter qui combine io.Reader et io.Writer.

Défi

Facile

Construisons un système de lecteur multimédia qui illustre la composition d’interfaces. Tu vas créer de petites interfaces ciblées, puis les combiner en une interface composée plus puissante qu’un seul type pourra satisfaire.

Tu vas organiser ton code sur deux fichiers :

media.go : définir trois interfaces et une structure qui les implémente toutes :
- une interface Player avec une méthode Play() string
- une interface Recorder avec une méthode Record(content string) string
- une interface MediaDevice qui compose à la fois Player et Recorder
- une structure SmartDevice avec un champ Name qui implémente toutes les méthodes requises
main.go : créer des fonctions qui montrent comment le même SmartDevice peut être utilisé via différents types d’interfaces. Écris trois fonctions :
- UsePlayer, qui accepte un Player et appelle sa méthode Play
- UseRecorder, qui accepte un Recorder et une chaîne de contenu, puis appelle Record
- UseMediaDevice, qui accepte un MediaDevice et une chaîne de contenu, puis appelle à la fois Record et Play
Lis le nom de l’appareil et le contenu depuis l’entrée, crée un SmartDevice, puis montre comment l’utiliser via les trois types d’interfaces.

Les entrées suivantes seront fournies :

Ligne 1 : nom de l’appareil
Ligne 2 : contenu à enregistrer

Vos méthodes doivent renvoyer des chaînes dans les formats suivants :

Play() : [Name] is playing
Record(content) : [Name] recorded: [content]

Par exemple, avec MyPhone et voice memo, votre sortie doit être :

MyPhone is playing
MyPhone recorded: voice memo
MyPhone recorded: voice memo
MyPhone is playing

Les deux premières lignes montrent l’appareil utilisé via les interfaces individuelles (Player et Recorder). Les deux dernières lignes montrent son utilisation via l’interface composée MediaDevice, qui requiert les deux capacités. Remarque comment ton unique SmartDevice satisfait les trois interfaces, car il possède les deux méthodes requises.

Essayez vous-même

package main

import (
	"bufio"
	"fmt"
	"os"
)

// TODO: Implémenter UsePlayer qui accepte un Player et appelle sa méthode Play
// Il doit afficher le résultat de Play()

// TODO: Implémenter UseRecorder qui accepte un Recorder et une chaîne content
// Il doit afficher le résultat de Record(content)

// TODO: Implémenter UseMediaDevice qui accepte un MediaDevice et une chaîne content
// Il doit afficher le résultat de Record(content) puis Play()

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	
	scanner.Scan()
	deviceName := scanner.Text()
	
	scanner.Scan()
	content := scanner.Text()
	
	// TODO: Créer un SmartDevice avec le nom donné
	
	// TODO: Utiliser l'appareil via l'interface Player
	
	// TODO: Utiliser l'appareil via l'interface Recorder
	
	// TODO: Utiliser l'appareil via l'interface MediaDevice
	
	_ = deviceName
	_ = content
	fmt.Println("Implement the solution")
}