Go Academy · Leçon

La composition plutôt que l’héritage

Découvrir la philosophie de conception de Go

La composition plutôt que l’héritage est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Go Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Go Academy comprend 4 leçons au total.

Philosophie de conception de Go

Go omet délibérément l’héritage de classes. L’approche idiomatique est la composition : construisez le comportement en combinant de petits types et de petites interfaces.

Pourquoi pas l’héritage

Les arborescences d’héritage profondes sont fragiles : une modification dans une classe de base se répercute de manière imprévisible. La composition maintient les relations explicites et flexibles.

La composition plutôt que l'héritage

Au lieu de dire « un gestionnaire est un employé », modélisez « un gestionnaire possède les données et les capacités d'un employé » au moyen de l'intégration ou de champs.

package main

import "fmt"

type Employee struct{ Name string }

func (e Employee) Work() string { return e.Name + " works" }

type Manager struct {
	Employee
	Reports int
}

func main() {
	m := Manager{Employee{"Lin"}, 3}
	fmt.Println(m.Work(), "-", m.Reports, "reports")
}

Programmez en fonction d'interfaces

Définissez le comportement à l'aide de petites interfaces, puis acceptez-les. Les implémentations sont interchangeables et faciles à remplacer ou à simuler.

package main

import "fmt"

type Notifier interface{ Notify(msg string) }

type Email struct{}

func (Email) Notify(msg string) { fmt.Println("email:", msg) }

func alert(n Notifier, m string) { n.Notify(m) }

func main() {
	alert(Email{}, "deploy done")
}

Remplacer les implémentations

Comme la fonction dépend d'une interface, vous pouvez lui transmettre n'importe quelle implémentation sans la modifier.

package main

import "fmt"

type Notifier interface{ Notify(msg string) }

type Email struct{}
type SMS struct{}

func (Email) Notify(m string) { fmt.Println("email:", m) }
func (SMS) Notify(m string)   { fmt.Println("sms:", m) }

func alert(n Notifier, m string) { n.Notify(m) }

func main() {
	alert(Email{}, "hi")
	alert(SMS{}, "hi")
}

Combiner les comportements

Intégrez plusieurs petits composants pour assembler un type riche en fonctionnalités à partir d'éléments indépendants et testables.

package main

import "fmt"

type Logger struct{}

func (Logger) Log(s string) { fmt.Println("log:", s) }

type Cache struct{ data map[string]string }

func (c Cache) Get(k string) string { return c.data[k] }

type Service struct {
	Logger
	Cache
}

func main() {
	s := Service{Cache: Cache{data: map[string]string{"k": "v"}}}
	s.Log("started")
	fmt.Println(s.Get("k"))
}

Injection de dépendances

Transmettez les dépendances, sous forme d'interfaces, aux constructeurs au lieu de les coder en dur. Il s'agit d'appliquer la composition au câblage.

package main

import "fmt"

type Store interface{ Save(s string) }

type MemStore struct{ items []string }

func (m *MemStore) Save(s string) { m.items = append(m.items, s) }

type App struct{ store Store }

func NewApp(s Store) *App { return &App{store: s} }

func main() {
	app := NewApp(&MemStore{})
	app.store.Save("x")
	fmt.Println("saved")
}

Les petites interfaces l'emportent

Plus une interface est petite, plus nombreux sont les types qui la satisfont et plus elle est facile à tester. Plus l'interface est grande, plus l'abstraction est faible.

Éviter la classe de base fragile

Sans héritage, aucune classe de base ne peut être cassée. Chaque élément composé évolue indépendamment, ce qui réduit le couplage.

Acceptez des interfaces, renvoyez des structures

Une recommandation courante en Go : les fonctions acceptent des interfaces, pour des entrées flexibles, et renvoient des structures concrètes, pour des sorties claires et utilisables.

Liste de vérification de la composition

Modélisez « possède » plutôt que « est un »
Intégrez de petits composants
Dépendez de petites interfaces
Injectez les dépendances

Vérification rapide

Évaluez vos connaissances de la philosophie de la composition.

Récapitulatif

Vous avez découvert la philosophie de la composition de Go.

Pas d'héritage ; composez avec l'intégration et les interfaces
Modélisez « possède » plutôt que « est un »
Programmez en fonction de petites interfaces et injectez les dépendances
Acceptez des interfaces et renvoyez des structures

Questions Fréquemment Posées

La leçon « La composition plutôt que l’héritage » est-elle gratuite ?

Oui — le texte complet de « La composition plutôt que l’héritage » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Go Academy, passe à CoddyKit PRO. Le cours Go Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « La composition plutôt que l’héritage » ?

Découvrir la philosophie de conception de Go Tu pratiques Go Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Go Academy ?

Aucune expérience préalable n'est requise. Go Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « La composition plutôt que l’héritage » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Go Academy ?

Oui. Chaque leçon Go Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Go Academy