Imbriquer plusieurs structs

Fait partie de la section Programmation Orientée Objet du Journey GO de Coddy — leçon 37 sur 107.

Go vous permet d'imbriquer plusieurs structs au sein d'une seule struct, combinant ainsi des comportements provenant de différentes sources. Cela est similaire à l'héritage multiple dans d'autres langages, mais avec l'approche de composition de Go.

type Logger struct{}

func (l Logger) Log(msg string) string {
    return "LOG: " + msg
}

type Notifier struct{}

func (n Notifier) Notify(msg string) string {
    return "NOTIFY: " + msg
}

type Service struct {
    Name string
    Logger
    Notifier
}

La structure Service a désormais accès aux méthodes des deux types intégrés :

func main() {
    s := Service{Name: "OrderService"}
    fmt.Println(s.Log("started"))      // LOG : démarré
    fmt.Println(s.Notify("new order")) // NOTIFY : nouvelle commande
}

Lors de l'imbrication de plusieurs structures, un conflit de nommage peut survenir si deux types imbriqués possèdent des méthodes portant le même nom. Go ne résout pas automatiquement cette ambiguïté :

type A struct{}
func (A) Greet() string { return "Hello from A" }

type B struct{}
func (B) Greet() string { return "Hello from B" }

type Combined struct {
    A
    B
}

func main() {
    c := Combined{}
    // c.Greet() - erreur de compilation : sélecteur ambigu
    fmt.Println(c.A.Greet())  // Hello from A
    fmt.Println(c.B.Greet())  // Hello from B
}

Lorsque des conflits surviennent, vous devez spécifier explicitement la méthode de quel type incorporé vous souhaitez appeler en utilisant le nom du type comme qualificateur.

Défi

Facile

Construisons un système d'appareil domestique intelligent qui combine plusieurs capacités grâce à l'imbrication de structures (struct embedding). Vous allez créer un appareil capable à la fois de contrôler l'éclairage et de diffuser de la musique en imbriquant des types de contrôleurs distincts.

Vous organiserez votre code sur trois fichiers :

controllers.go : Créez deux structures de contrôleur indépendantes qui fournissent des capacités différentes :
- Un LightController avec un champ Brightness (int) et une méthode SetLight(level int) string qui retourne "Light set to [level]%"
- Un AudioController avec un champ Volume (int) et une méthode SetVolume(level int) string qui retourne "Volume set to [level]%"
Les deux contrôleurs doivent également avoir une méthode Status() string — cela crée un conflit de nommage que vous devrez gérer. LightController.Status() doit retourner "Brightness: [Brightness]%" et AudioController.Status() doit retourner "Volume: [Volume]%".
device.go : Créez une structure SmartDevice avec un champ Name qui imbrique à la fois LightController et AudioController. Ajoutez une méthode appelée FullStatus() string qui retourne le nom de l'appareil ainsi que les statuts des deux contrôleurs, en résolvant l'ambiguïté par l'appel explicite de la méthode Status() de chaque type imbriqué.
main.go : Lisez la configuration de l'appareil depuis l'entrée, créez un SmartDevice, utilisez les méthodes promues pour régler les niveaux de lumière et de volume, puis affichez le statut complet.

Les entrées suivantes seront fournies :

Ligne 1 : Nom de l'appareil
Ligne 2 : Niveau de luminosité initial (entier)
Ligne 3 : Niveau de volume initial (entier)
Ligne 4 : Nouveau niveau de luminosité à régler (entier)
Ligne 5 : Nouveau niveau de volume à régler (entier)

Votre méthode FullStatus() doit retourner :

[Name] - [LightController.Status()], [AudioController.Status()]

Affichez les résultats de l'appel à SetLight et SetVolume (qui sont promus depuis les types imbriqués), puis affichez le statut complet.

Par exemple, avec Living Room Hub, 50, 30, 75, et 60, votre sortie devrait être :

Light set to 75%
Volume set to 60%
Living Room Hub - Brightness: 75%, Volume: 60%

Remarquez comment SetLight et SetVolume sont directement accessibles sur SmartDevice grâce à la promotion de méthode, mais Status() nécessite une qualification explicite car les deux types imbriqués possèdent cette méthode.

Aide-mémoire

Go permet l'imbrication de plusieurs structures au sein d'une seule structure, combinant ainsi les comportements de différentes sources par composition :

type Logger struct{}

func (l Logger) Log(msg string) string {
    return "LOG: " + msg
}

type Notifier struct{}

func (n Notifier) Notify(msg string) string {
    return "NOTIFY: " + msg
}

type Service struct {
    Name string
    Logger
    Notifier
}

La structure Service a accès aux méthodes des deux types imbriqués :

s := Service{Name: "OrderService"}
fmt.Println(s.Log("started"))      // LOG: started
fmt.Println(s.Notify("new order")) // NOTIFY: new order

Des conflits de nommage surviennent lorsque les types imbriqués possèdent des méthodes portant le même nom. Vous devez alors spécifier explicitement la méthode du type imbriqué à appeler :

type A struct{}
func (A) Greet() string { return "Hello from A" }

type B struct{}
func (B) Greet() string { return "Hello from B" }

type Combined struct {
    A
    B
}

// c.Greet() - compile error: ambiguous selector
c := Combined{}
fmt.Println(c.A.Greet())  // Hello from A
fmt.Println(c.B.Greet())  // Hello from B

Essayez vous-même

package main

import (
	"fmt"
)

func main() {
	// Lire l'entrée
	var name string
	fmt.Scanln(&name)

	var initialBrightness int
	fmt.Scanln(&initialBrightness)

	var initialVolume int
	fmt.Scanln(&initialVolume)

	var newBrightness int
	fmt.Scanln(&newBrightness)

	var newVolume int
	fmt.Scanln(&newVolume)

	// TODO: Créer un SmartDevice avec le nom et les valeurs initiales donnés

	// TODO: Utiliser la méthode SetLight promue et afficher le résultat

	// TODO: Utiliser la méthode SetVolume promue et afficher le résultat

	// TODO: Afficher le statut complet en utilisant la méthode FullStatus()
}