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 l'implémentant possède une méthode Speak() qui retourne une chaîne de caractères. Désormais, toute structure possédant 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!"
}

À la fois Dog et Cat satisfont 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 woof !
    MakeSound(cat)  // Whiskers dit meow !
}

Les interfaces vous permettent d'écrire du code flexible et réutilisable qui fonctionne avec n'importe quel type répondant aux exigences de l'interface, indépendamment de l'implémentation sous-jacente.

Défi

Facile

Construisons un système de description de véhicules qui dé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 n'importe quel véhicule de manière uniforme.

Vous organiserez votre code sur deux fichiers :

vehicles.go : Définissez une interface Describer avec une seule méthode Describe() string. Créez ensuite deux structs qui satisfont cette interface :
- Car avec les champs Brand et Model (tous deux des chaînes de caractères)
- Bicycle avec les champs Type (chaîne de caractères) et Gears (entier)
Chaque struct doit avoir une méthode Describe() qui retourne une chaîne descriptive sur le 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 à sa méthode Describe(). Lisez les informations du véhicule à partir de l'entrée, créez à la fois une Car et un Bicycle, et utilisez votre fonction pour afficher les descriptions de chacun.

Les entrées suivantes seront fournies :

Ligne 1 : Marque de la voiture (Car brand)
Ligne 2 : Modèle de la voiture (Car model)
Ligne 3 : Type de vélo (Bicycle type)
Ligne 4 : Nombre de vitesses (Number of gears, entier)

Vos méthodes Describe() doivent retourner des chaînes de caractères selon ces formats :

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 clé est que votre fonction PrintDescription fonctionne avec n'importe quel type possédant une méthode Describe() — elle n'a pas besoin de savoir si elle traite une Car, un Bicycle ou tout autre type de véhicule que vous pourriez ajouter plus tard.

Aide-mémoire

Une interface en Go définit un ensemble de signatures de méthodes sans les implémenter. Tout type qui implémente toutes les méthodes satisfait automatiquement cette interface.

Définition d'une interface :

type Speaker interface {
    Speak() string
}

Les types qui implémentent les méthodes requises satisfont l'interface :

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

Les fonctions peuvent accepter n'importe quel type qui satisfait l'interface :

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

func main() {
    dog := Dog{Name: "Buddy"}
    cat := Cat{Name: "Whiskers"}
    
    MakeSound(dog)  // Buddy says woof!
    MakeSound(cat)  // Whiskers says meow!
}

Essayez vous-même

package main

import (
	"fmt"
)

// TODO: Créer une fonction PrintDescription qui accepte n'importe quel Describer
// et affiche 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 de l'entrée

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

	// TODO: Utiliser PrintDescription pour afficher la description de la car

	// TODO: Utiliser PrintDescription pour afficher la description de la bicycle
}