Masquage des méthodes incluses

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

Parfois, vous avez besoin que la structure externe fournisse sa propre implémentation d’une méthode que le type intégré possède déjà. C’est ce qu’on appelle la dissimulation, et cela vous permet de remplacer les méthodes promues par un comportement personnalisé.

Lorsque tu définis une méthode sur la structure externe portant le même nom qu’une méthode intégrée, la méthode externe est prioritaire :

type Animal struct {
    Name string
}

func (a Animal) Speak() string {
    return "Some sound"
}

type Dog struct {
    Animal
    Breed string
}

func (d Dog) Speak() string {
    return "Woof!"
}

Maintenant, lorsque vous appelez Speak() sur un Dog, la méthode externe est utilisée :

func main() {
    d := Dog{Animal: Animal{Name: "Rex"}, Breed: "Labrador"}
    
    fmt.Println(d.Speak())        // Woof! - méthode de Dog
    fmt.Println(d.Animal.Speak()) // Some sound - méthode d'Animal
}

La méthode intégrée n’a pas disparu. Vous pouvez toujours y accéder explicitement via le nom du type intégré. Ce modèle est utile lorsque vous souhaitez personnaliser le comportement tout en conservant l’implémentation d’origine disponible, par exemple pour l’appeler depuis votre méthode de remplacement :

func (d Dog) Speak() string {
    return d.Animal.Speak() + " (but actually Woof!)"
}

Le masquage vous permet de contrôler le comportement exposé tout en conservant l’accès à l’original grâce à une qualification explicite.

Défi

Facile

Construisons un système de notifications dans lequel différents canaux de notification peuvent personnaliser la façon dont ils formatent et distribuent les messages. Tu utiliseras le masquage de méthodes pour permettre à des canaux spécifiques de remplacer le comportement par défaut, tout en pouvant accéder à l’implémentation d’origine lorsque cela est nécessaire.

Tu organiseras ton code dans trois fichiers :

base.go : crée une structure BaseNotification avec des champs Title et Priority (tous deux de type chaîne). Donne-lui une méthode Format() string qui renvoie la notification dans un format standard : [Priority] Title.
channels.go : crée deux types de canaux de notification qui intègrent BaseNotification et masquent la méthode Format avec leurs propres implémentations :
- EmailNotification avec un champ Recipient. Sa méthode Format() doit renvoyer Email to [Recipient]: [Priority] Title
- SlackNotification avec un champ Channel. Sa méthode Format() doit appeler la méthode BaseNotification.Format() intégrée et préfixer le résultat avec #[Channel]:
main.go : lis les détails de la notification depuis l’entrée, crée les deux types de notifications et montre le masquage en affichant :
1. la sortie formatée de EmailNotification (en utilisant sa méthode masquée)
2. le format de base de EmailNotification (en appelant explicitement la méthode intégrée)
3. la sortie formatée de SlackNotification (qui utilise en interne la méthode de base)

Les entrées suivantes seront fournies :

Ligne 1 : titre de la notification
Ligne 2 : niveau de priorité
Ligne 3 : destinataire de l’e-mail
Ligne 4 : nom du canal Slack

Par exemple, avec Server Alert, HIGH, admin@company.com et ops-alerts, ta sortie devrait être :

Email to admin@company.com: HIGH Server Alert
[HIGH] Server Alert
#ops-alerts: [HIGH] Server Alert

Remarque que EmailNotification remplace complètement le formatage de base, tandis que SlackNotification l’enrichit en appelant la méthode d’origine et en ajoutant le contexte du canal. Les deux approches illustrent différentes façons d’utiliser efficacement le masquage de méthodes.

Essayez vous-même

package main

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

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	
	// Lire le titre de la notification
	scanner.Scan()
	title := scanner.Text()
	
	// Lire le niveau de priorité
	scanner.Scan()
	priority := scanner.Text()
	
	// Lire le destinataire de l'e-mail
	scanner.Scan()
	recipient := scanner.Text()
	
	// Lire le nom du canal Slack
	scanner.Scan()
	channel := scanner.Text()
	
	// TODO: Créer une EmailNotification avec la notification de base, title, priority et recipient
	
	// TODO: Créer une SlackNotification avec la notification de base, title, priority et channel
	
	// TODO: Afficher la sortie formatée de l'EmailNotification (en utilisant sa méthode masquée)
	
	// TODO: Afficher le format de base de l'EmailNotification (en appelant explicitement la méthode embarquée)
	
	// TODO: Afficher la sortie formatée de la SlackNotification
	
	fmt.Println() // Espace réservé - à supprimer lors de l'implémentation
}