Go Academy · Lektion

Komposition statt Vererbung

Die Designphilosophie von Go

Komposition statt Vererbung ist eine kostenlose Go Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Go Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.

Gos Designphilosophie

Go verzichtet bewusst auf Klassenvererbung. Der idiomatische Ansatz ist die Komposition: Bauen Sie Verhalten auf, indem Sie kleine Typen und Interfaces kombinieren.

Warum keine Vererbung

Tiefe Vererbungsbäume sind fragil: Eine Änderung an einer Basisklasse wirkt sich unvorhersehbar auf viele Stellen aus. Komposition hält Beziehungen explizit und flexibel.

Has-a statt Is-a

Modellieren Sie nicht „ein Manager ist ein Employee“, sondern „ein Manager besitzt die Daten und Fähigkeiten eines Employee“ – durch Embedding oder Felder.

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

Auf Interfaces programmieren

Definieren Sie das Verhalten mit kleinen Interfaces und akzeptieren Sie diese. Implementierungen sind austauschbar und lassen sich leicht ersetzen oder mocken.

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

Implementierungen austauschen

Da die Funktion von einem Interface abhängt, können Sie jede beliebige Implementierung übergeben, ohne die Funktion zu ändern.

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

Verhalten kombinieren

Binden Sie mehrere kleine Komponenten ein, um aus unabhängigen, testbaren Teilen einen funktionsreichen Typ zusammenzusetzen.

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

Dependency Injection

Übergeben Sie Abhängigkeiten als Interfaces an Konstruktoren, statt sie fest zu codieren. Das ist Komposition, angewendet auf die Verdrahtung.

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

Kleine Interfaces gewinnen

Je kleiner ein Interface ist, desto mehr Typen erfüllen es und desto leichter lässt es sich testen. Je größer das Interface, desto schwächer die Abstraktion.

Die fragile Basisklasse vermeiden

Ohne Vererbung gibt es keine Basisklasse, die Probleme verursachen kann. Jeder zusammengesetzte Teil entwickelt sich unabhängig weiter, wodurch die Kopplung abnimmt.

Interfaces akzeptieren, Structs zurückgeben

Eine verbreitete Go-Richtlinie: Funktionen akzeptieren Interfaces (flexible Eingaben) und geben konkrete Structs zurück (klare, nutzbare Ausgaben).

Kompositions-Checkliste

Has-a statt Is-a modellieren
Kleine Komponenten einbinden
Von kleinen Interfaces abhängen
Abhängigkeiten injizieren

Kurztest

Testen Sie Ihr Wissen über die Kompositionsphilosophie.

Zusammenfassung

Sie haben Go's Kompositionsphilosophie kennengelernt.

Keine Vererbung; stattdessen mit Embedding und Interfaces zusammensetzen
Has-a statt Is-a modellieren
Auf kleine Interfaces programmieren und Abhängigkeiten injizieren
Interfaces akzeptieren, Structs zurückgeben

Häufig gestellte Fragen

Ist die Lektion „Komposition statt Vererbung“ kostenlos?

Ja — der vollständige Text von „Komposition statt Vererbung“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Go Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Komposition statt Vererbung“?

Die Designphilosophie von Go Du übst Go Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Go Academy zu starten?

Keine Vorkenntnisse erforderlich. Go Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Komposition statt Vererbung“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Go Academy-Lektion Code schreiben und ausführen?

Ja. Jede Go Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Go Academy