Récapitulatif - Formes et comportements

Fait partie de la section Logique & Flux du Journey GO de Coddy — leçon 19 sur 68.

Défi

Facile

Dans ce défi, vous allez créer un système de communication qui démontre le polymorphisme à travers les interfaces. Vous allez construire une interface Speaker et l'implémenter avec différents types qui peuvent « parler » de leur propre manière unique.

Vous recevrez trois entrées :

Une chaîne représentant le nombre de locuteurs à créer (par exemple, "3")
Une chaîne contenant les types de locuteurs séparés par des virgules (par exemple, "person,parrot,person")
Une chaîne contenant les noms des locuteurs séparés par des virgules (par exemple, "Alice,Polly,Bob")

Votre tâche consiste à :

Définir une interface Speaker avec une signature de méthode : Speak() qui retourne une chaîne de caractères
Définir une structure Person avec un champ Name (string)
Définir une structure Parrot avec un champ Name (string)
Implémenter la méthode Speak() pour les deux structures :
- Person doit retourner : "Hello, I'm [name]"
- Parrot doit retourner : "Squawk! [name] says hello!"
Créer une fonction nommée makeAllSpeak qui prend une tranche (slice) d'interfaces Speaker en paramètre
À l'intérieur de makeAllSpeak, parcourir la tranche et appeler la méthode Speak() sur chaque locuteur, en affichant le résultat
Analyser les entrées pour créer les instances de locuteurs appropriées en fonction des types et des noms fournis
Stocker tous les locuteurs dans une tranche d'interfaces Speaker
Appeler makeAllSpeak avec votre tranche de locuteurs

Les locuteurs doivent être créés dans l'ordre où ils apparaissent dans l'entrée. Par exemple, si les types sont "person,parrot,person" et les noms sont "Alice,Polly,Bob", créez une Person nommée Alice, puis un Parrot nommé Polly, puis une Person nommée Bob. Ce défi démontre comment différents types peuvent être traités de manière uniforme via une interface partagée, illustrant la puissance du polymorphisme en Go.

Essayez vous-même

package main

import (
	"fmt"
	"strconv"
	"strings"
)

func main() {
	// Lire l'entrée
	var numSpeakersStr string
	var speakerTypesStr string
	var speakerNamesStr string
	
	fmt.Scanln(&numSpeakersStr)
	fmt.Scanln(&speakerTypesStr)
	fmt.Scanln(&speakerNamesStr)
	
	// Analyser l'entrée
	numSpeakers, _ := strconv.Atoi(numSpeakersStr)
	speakerTypes := strings.Split(speakerTypesStr, ",")
	speakerNames := strings.Split(speakerNamesStr, ",")
	
	// TODO: Écrivez votre code ci-dessous
	// 1. Définir l'interface Speaker
	// 2. Définir les structures Person et Parrot
	// 3. Implémenter les méthodes Speak() pour les deux structures
	// 4. Créer la fonction makeAllSpeak
	// 5. Créer les haut-parleurs (speakers) basés sur l'entrée et les stocker dans une tranche (slice)
	// 6. Appeler makeAllSpeak avec votre tranche
	
}

Toutes les leçons de Logique & Flux

3Interfaces (Les bases)

Qu'est-ce qu'une Interface ?Définir une Interface Implémenter une Interface Utiliser les types d'Interface Interface vide Assertions de type Type SwitchRécapitulatif - Formes et comportements

6Go idiomatique : Les ensembles

L'idiome des ensembles en Go Créer un ensemble Ajouter à un ensemble Vérifier l'appartenance Supprimer d'un ensemble Itérer sur un ensemble Récapitulatif - Noms d'utilisateur uniques

9Packages et Portée

Qu'est-ce qu'un Package ?Exporté vs Non-exporté Créer un Package Simple Aliasing de Package L'identificateur blanc `_`La fonction `init`Récapitulatif - Créer un utilitaire