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 construire des interfaces plus larges en composant des interfaces plus petites. Au lieu de définir une seule grande interface avec de nombreuses méthodes, vous imbriquez des interfaces existantes à l'intérieur de 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 à la fois les méthodes Read() et Write(). Tout type qui implémente les 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 démontre la composition d'interfaces. Vous allez créer de petites interfaces ciblées, puis les combiner en une interface composée plus puissante qu'un seul type peut satisfaire.

Vous organiserez votre code sur deux fichiers :

media.go : Définissez 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éez des fonctions qui démontrent comment le même SmartDevice peut être utilisé via différents types d'interfaces. Écrivez trois fonctions :
- UsePlayer qui accepte un Player et appelle sa méthode Play
- UseRecorder qui accepte un Recorder et une chaîne de caractères de contenu, puis appelle Record
- UseMediaDevice qui accepte un MediaDevice et une chaîne de caractères de contenu, puis appelle à la fois Record et Play
Lisez le nom de l'appareil et le contenu depuis l'entrée, créez un SmartDevice, et démontrez son utilisation à travers 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 retourner des chaînes de caractères selon ces formats :

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

Par exemple, avec MyPhone et voice memo, votre sortie devrait ê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 le montrent utilisé via l'interface composée MediaDevice, qui requiert les deux capacités. Remarquez comment votre unique SmartDevice satisfait les trois interfaces car il possède les deux méthodes requises.

Aide-mémoire

Go vous permet de construire des interfaces plus larges en composant des plus petites, en imbriquant des interfaces existantes à l'intérieur d'une nouvelle définition d'interface :

type Reader interface {
    Read() string
}

type Writer interface {
    Write(data string)
}

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

Tout type qui implémente toutes les méthodes des interfaces imbriquées satisfait l'interface composée :

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
}

Un type qui implémente une interface composée satisfait également chacune des interfaces imbriquées individuellement. Cette approche de composition permet de garder les interfaces petites et ciblées tout en vous permettant de créer des contrats précis pour vos fonctions.

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