Go Academy · Lekcja

Kompozycja zamiast dziedziczenia

Filozofia projektowa Go

Kompozycja zamiast dziedziczenia to bezpłatna lekcja Go Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Go Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Go Academy zawiera 4 lekcji w sumie.

Filozofia projektowa Go

Go celowo pomija dziedziczenie klas. Idiomatyczne podejście to kompozycja: budowanie zachowania przez łączenie małych typów i interfejsów.

Dlaczego nie dziedziczenie

Głębokie hierarchie dziedziczenia są kruche: zmiana w klasie bazowej rozchodzi się w nieprzewidywalny sposób. Kompozycja zachowuje jawność i elastyczność relacji.

Has-a zamiast Is-a

Zamiast modelować relację „Manager jest Employee”, należy modelować ją jako „Manager ma dane i możliwości Employee” za pomocą osadzania lub pól.

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

Programowanie z użyciem interfejsów

Zdefiniuj zachowanie za pomocą małych interfejsów, a następnie przyjmuj te interfejsy. Implementacje można wymieniać, łatwo zastępować i mockować.

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

Wymiana implementacji

Ponieważ funkcja zależy od interfejsu, można przekazać dowolną implementację bez zmieniania funkcji.

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

Łączenie zachowań

Osadź wiele małych komponentów, aby złożyć typ o bogatych możliwościach z niezależnych, łatwych do testowania elementów.

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

Wstrzykiwanie zależności

Przekazuj zależności jako interfejsy do konstruktorów, zamiast definiować je na stałe w kodzie. To zastosowanie kompozycji do łączenia elementów.

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

Małe interfejsy wygrywają

Im mniejszy interfejs, tym więcej typów go spełnia i tym łatwiej go testować. Im większy interfejs, tym słabsza abstrakcja.

Unikanie kruchej klasy bazowej

Bez dziedziczenia nie ma klasy bazowej, którą można przypadkowo zepsuć. Każdy złożony element rozwija się niezależnie, co zmniejsza sprzężenie.

Przyjmuj interfejsy, zwracaj struktury

Popularna wskazówka dotycząca Go: funkcje powinny przyjmować interfejsy (elastyczne dane wejściowe) i zwracać konkretne struktury (jasne, użyteczne wyniki).

Lista kontrolna kompozycji

Modeluj has-a, nie is-a
Osadzaj małe komponenty
Zależ od małych interfejsów
Wstrzykuj zależności

Szybkie sprawdzenie

Sprawdź swoją wiedzę o podejściu opartym na kompozycji.

Podsumowanie

Poznałeś filozofię kompozycji w Go.

Brak dziedziczenia; używaj kompozycji za pomocą osadzania i interfejsów
Modeluj has-a zamiast is-a
Programuj względem małych interfejsów i wstrzykuj zależności
Przyjmuj interfejsy, zwracaj struktury

Często zadawane pytania

Czy lekcja „Kompozycja zamiast dziedziczenia” jest bezpłatna?

Tak — pełny tekst „Kompozycja zamiast dziedziczenia” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Go Academy, przejdź na CoddyKit PRO. Kurs Go Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Kompozycja zamiast dziedziczenia”?

Filozofia projektowa Go Ćwiczysz Go Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Go Academy?

Nie wymagamy żadnego doświadczenia. Go Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Kompozycja zamiast dziedziczenia”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Go Academy?

Tak. Każda lekcja Go Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Go Academy