Go Academy · Lezione

Composizione anziché ereditarietà

La filosofia progettuale di Go

Composizione anziché ereditarietà è una lezione Go Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Go Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Go Academy include 4 lezioni in totale.

Filosofia progettuale di Go

Go omette deliberatamente l'ereditarietà tra classi. L'approccio idiomatico è la composizione: costruire il comportamento combinando piccoli tipi e interfacce.

Perché non usare l'ereditarietà

Le gerarchie di ereditarietà profonde sono fragili: una modifica a una classe base si propaga in modo imprevedibile. La composizione mantiene le relazioni esplicite e flessibili.

Has-a invece di Is-a

Invece di modellare «un Manager è un Employee», modelli «un Manager ha i dati e le funzionalità di un Employee» tramite embedding o campi.

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

Programmare verso le interfacce

Definisca il comportamento con interfacce piccole, quindi accetti valori che le implementano. Le implementazioni sono intercambiabili e facili da sostituire o simulare con mock.

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

Sostituire le implementazioni

Poiché la funzione dipende da un'interfaccia, può passarle qualsiasi implementazione senza modificare la funzione.

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

Combinare i comportamenti

Incorpori più componenti piccoli per assemblare un tipo ricco di funzionalità a partire da parti indipendenti e testabili.

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

Iniezione delle dipendenze

Passi le dipendenze, sotto forma di interfacce, ai costruttori anziché codificarle direttamente. Questa è la composizione applicata al collegamento delle dipendenze.

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

Le interfacce piccole sono migliori

Più un'interfaccia è piccola, più tipi la soddisfano e più facile è testarla. Più grande è l'interfaccia, più debole è l'astrazione.

Evitare la classe base fragile

Senza ereditarietà non c'è alcuna classe base che possa rompersi. Ogni parte composta evolve in modo indipendente, riducendo l'accoppiamento.

Accetti interfacce, restituisca struct

Una linea guida comune in Go: le funzioni accettano interfacce, per ottenere input flessibili, e restituiscono struct concrete, per fornire output chiari e utilizzabili.

Checklist della composizione

Modelli has-a, non is-a
Incorpori componenti piccoli
Dipenda da interfacce piccole
Inietti le dipendenze

Verifica rapida

Verifichi la sua conoscenza della filosofia della composizione.

Riepilogo

Ha imparato la filosofia della composizione in Go.

Niente ereditarietà; usi la composizione con embedding e interfacce
Modelli has-a invece di is-a
Programmi verso interfacce piccole e inietti le dipendenze
Accetti interfacce e restituisca struct

Domande Frequenti

La lezione «Composizione anziché ereditarietà» è gratuita?

Sì — il testo completo di «Composizione anziché ereditarietà» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Go Academy, passa a CoddyKit PRO. Il corso Go Academy include 4 lezioni in totale.

Cosa imparerò in «Composizione anziché ereditarietà»?

La filosofia progettuale di Go Eserciti Go Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Go Academy?

Non è richiesta alcuna esperienza precedente. Go Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Composizione anziché ereditarietà»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Go Academy?

Sì. Ogni lezione Go Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Go Academy