Introduction aux interfaces

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

Une interface en Go définit un ensemble de signatures de méthodes sans les implémenter. Elle décrit ce qu’un type peut faire, et non comment il le fait. Tout type qui implémente toutes les méthodes d’une interface satisfait automatiquement cette interface.

Voici comment définir une interface :

type Speaker interface {
    Speak() string
}

Cette interface Speaker exige que tout type qui l’implémente possède une méthode Speak() qui renvoie une chaîne. Désormais, toute structure dotée de cette méthode peut être utilisée partout où un Speaker est attendu.

type Dog struct {
    Name string
}

func (d Dog) Speak() string {
    return d.Name + " says woof!"
}

type Cat struct {
    Name string
}

func (c Cat) Speak() string {
    return c.Name + " says meow!"
}

Dog et Cat satisfont tous deux à l’interface Speaker, car ils possèdent chacun une méthode Speak() avec la signature correcte. Vous pouvez maintenant écrire des fonctions qui acceptent n’importe quel Speaker :

func MakeSound(s Speaker) {
    fmt.Println(s.Speak())
}

func main() {
    dog := Dog{Name: "Buddy"}
    cat := Cat{Name: "Whiskers"}
    
    MakeSound(dog)  // Buddy dit ouaf !
    MakeSound(cat)  // Whiskers dit miaou !
}

Les interfaces vous permettent d’écrire du code flexible et réutilisable qui fonctionne avec tout type répondant aux exigences de l’interface, quelle que soit l’implémentation sous-jacente.

Défi

Facile

Construisons un système de description de véhicules qui montre comment les interfaces permettent à différents types de partager un comportement commun. Vous allez créer une interface que plusieurs types de véhicules peuvent satisfaire, puis l'utiliser pour décrire uniformément n'importe quel véhicule.

Vous allez organiser votre code sur deux fichiers :

vehicles.go : définissez une interface Describer avec une seule méthode Describe() string. Créez ensuite deux structures qui satisfont cette interface :
- Car avec les champs Brand et Model (tous deux de type chaîne de caractères)
- Bicycle avec les champs Type (chaîne de caractères) et Gears (entier)
Chaque structure doit avoir une méthode Describe() qui renvoie une chaîne descriptive du véhicule.
main.go : créez une fonction appelée PrintDescription qui accepte n'importe quel Describer et affiche le résultat de l'appel de sa méthode Describe(). Lisez les informations sur les véhicules depuis l'entrée, créez un Car et un Bicycle, puis utilisez votre fonction pour afficher la description de chacun.

Les entrées suivantes seront fournies :

Ligne 1 : marque de la voiture
Ligne 2 : modèle de la voiture
Ligne 3 : type de bicyclette
Ligne 4 : nombre de vitesses (entier)

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

Car : [Brand] [Model]
Bicycle : [Type] bike with [Gears] gears

Par exemple, avec Toyota, Camry, Mountain et 21, votre sortie devrait être :

Toyota Camry
Mountain bike with 21 gears

L'idée essentielle est que votre fonction PrintDescription fonctionne avec tout type possédant une méthode Describe(). Elle n'a pas besoin de savoir si elle traite un Car, un Bicycle ou tout autre type de véhicule que vous pourriez ajouter ultérieurement.

Essayez vous-même

package main

import (
	"fmt"
)

// TODO: Créer une fonction PrintDescription qui accepte n'importe quel Describer
// et imprime le résultat de l'appel de sa méthode Describe()

func main() {
	// Lire l'entrée
	var carBrand string
	var carModel string
	var bicycleType string
	var gears int

	fmt.Scanln(&carBrand)
	fmt.Scanln(&carModel)
	fmt.Scanln(&bicycleType)
	fmt.Scanln(&gears)

	// TODO: Créer une Car avec la marque et le modèle issus de l'entrée

	// TODO: Créer une Bicycle avec le type et les vitesses issus de l'entrée

	// TODO: Utiliser PrintDescription pour imprimer la description de la voiture

	// TODO: Utiliser PrintDescription pour imprimer la description du vélo
}