Po tej lekcji będziesz potrafić:

• odróżniać relację dziedziczenia jest-rodzajem od relacji kompozycji ma.
• zbudować klasę, która otrzymuje i przechowuje obiekt współpracujący (collaborator).
• delegować pracę do tego obiektu przez wspólną metodę.
• wymieniać obiekty współpracujące bez zmiany klasy, która ich używa.

Dziedziczenie mówi, że jedna klasa jest rodzajem innej klasy (class PremiumAccount(Account)). Kompozycja mówi, że obiekt ma inny obiekt, który pomaga mu w pracy (Notifier ma Formatter). Oba wzorce są użyteczne, ale dziedziczenie powinno odzwierciedlać prawdziwą relację typów, a nie być skrótem do ponownego użycia kodu.

W kompozycji konstruktor obiektu zewnętrznego otrzymuje obiekt współpracujący i go przechowuje. Następnie deleguje pracę: self.formatter.render(message). Dostarczenie obiektu współpracującego z zewnątrz (wstrzykiwanie przez konstruktor) ułatwia zmianę zachowania i testowanie klasy zewnętrznej bez jej edycji.

Nie twórz automatycznie w konstruktorze zastępczego obiektu współpracującego, gdy wywołujący dostarczył własny; zignorowałoby to wybrane zachowanie. Kompozycja pozwala też uniknąć długich łańcuchów dziedziczenia, gdy jedynym celem jest połączenie oddzielnych odpowiedzialności.

1. Usługa ma formatter

class Formatter:
    def render(self, value):
        return value.upper()

class Service:
    def __init__(self, formatter):
        self.formatter = formatter

    def output(self, value):
        return self.formatter.render(value)

service = Service(Formatter())
print(service.output("ready"))

Wynik:

READY

2. Wymiana obiektu współpracującego

Dwa formattery mają tę samą metodę, ale dają różne wyniki.

class PlainFormatter:
    def render(self, message):
        return message

class BracketFormatter:
    def render(self, message):
        return f"[{message}]"

class Reporter:
    def __init__(self, formatter):
        self.formatter = formatter

    def report(self, message):
        return self.formatter.render(message)

print(Reporter(PlainFormatter()).report("ok"))
print(Reporter(BracketFormatter()).report("ok"))

Wynik:

ok
[ok]

3. Porównanie z relacją „jest”

Dziedziczenie jest właściwe, gdy klasa potomna naprawdę jest wyspecjalizowanym typem swojej klasy nadrzędnej.

class Storage:
    def kind(self):
        return "storage"

class CloudStorage(Storage):
    def kind(self):
        return "cloud storage"

print(CloudStorage().kind())

Wynik:

cloud storage

Magazyn w chmurze jest rodzajem magazynu; usługa ma formatter.

4. Złożenie polityki i delegowanie decyzji

class RetryPolicy:
    def can_retry(self, attempt):
        return attempt < 3

class Worker:
    def __init__(self, policy):
        self.policy = policy

    def should_retry(self, attempt):
        return self.policy.can_retry(attempt)

print(Worker(RetryPolicy()).should_retry(2))

Wynik:

True

1. Dziedziczenie po obiekcie współpracującym, mimo że relacja brzmi „ma”.
2. Ignorowanie wstrzykniętego obiektu współpracującego i tworzenie nowego, wpisanego na stałe.
3. Zapominanie o delegowaniu przez zapisaną instancję (self.formatter).
4. Wiązanie klasy zewnętrznej z jedną implementacją, gdy powinno działać wiele zgodnych obiektów współpracujących.