Summary  
This chapter covers the object-oriented composition pattern, where complex functionality is built by containing and delegating to independent component objects—using constructor and setter injection—to achieve modularity, flexibility, and testability.  

General domain of usage  
E-commerce order processing

Komposition fokuserar på att bygga komplexa objekt genom att kombinera enklare, oberoende komponenter. Istället för att förlita sig på arv, vilket skapar stela hierarkier, möjliggör komposition att klasser samarbetar genom inneslutna objekt. Detta tillvägagångssätt gör systemen mer **flexibla**, **modulära** och **lättare att underhålla**, eftersom komponenter kan bytas ut eller utökas utan att hela strukturen bryts.

class Payment:
    def pay(self, amount):
        return f"Paid {amount}"


class Inventory:
    def reserve(self, item):
        return f"{item} reserved"


class Shipping:
    def ship(self, item):
        return f"{item} shipped"


class Order:
    def __init__(self, item, price, payment, inventory, shipping):
        self.item = item
        self.price = price
        self.payment = payment
        self.inventory = inventory
        self.shipping = shipping

    def process(self):
        return " | ".join([
            self.inventory.reserve(self.item),
            self.payment.pay(self.price),
            self.shipping.ship(self.item)
        ])


order = Order("Laptop", 1200, Payment(), Inventory(), Shipping())
print(order.process())

`Order` implementerar inte själv logiken för betalning, lager eller leverans.
Istället **har** den separata objekt (`Payment`, `Inventory`, `Shipping`) och använder dem för att utföra sitt arbete.

Varje komponent har ett ansvar, och `Order` koordinerar endast dessa.
Om du vill ändra hur betalning eller leverans fungerar kan du byta ut komponenten utan att ändra klassen `Order`.


Några fallgropar att se upp för vid användning av komposition är att skapa **gudobjekt** som samlar för många komponenter och blir svåra att hantera, **läckande komponent-API:er** genom den yttre klassen istället för att behålla ett rent gränssnitt, samt att introducera **dold koppling** när komponenter är för beroende av varandras interna detaljer.


Ett god-objekt försöker göra för mycket. Det innehåller många komponenter och hanterar många ansvarsområden, vilket gör klassen svår att förstå, testa och underhålla.

God-objekt

Detta inträffar när den yttre klassen exponerar de interna metoderna eller attributen hos sina komponenter. Istället för att erbjuda ett eget tydligt gränssnitt tvingar den användare att interagera direkt med interna objekt.

Läckande komponent-API:er

Komponenter blir tätt sammankopplade genom interna detaljer. Att ändra en del kan oväntat förstöra en annan eftersom de är beroende av varandras interna struktur istället för tydliga kontrakt.

Dold koppling

Vilken vanlig risk finns vid användning av komposition som kan göra designen svårare att underhålla?

Lär dig att bygga rena, säkra och skalbara applikationer med objektorienterad programmering i Python. Täck grunderna i klasser och objekt, och gå sedan vidare till avancerade koncept såsom arv, komposition, polymorfism och inkapsling. Med tydliga förklaringar och praktiska exempel utvecklar du förmågan att designa Python-program som är kraftfulla, underhållbara och redo för verklig användning.

Lär dig de grundläggande byggstenarna i objektorienterad programmering i Python. Detta avsnitt behandlar klasser, objekt, metoder och variabler, vilket ger en stabil grund för att förstå hur OOP organiserar och strukturerar kod.

Utforska hur klasser kan dela och utöka funktionalitet. Du kommer att lära dig olika arvsmönster, från enkla hierarkier till multipelt arv och abstrakta klasser, och se hur dessa möjliggör återanvändning av kod och skalbarhet.

Upptäck hur du bygger flexibla system genom att kombinera objekt. Istället för att enbart förlita dig på arv, visar vi hur komposition gör det möjligt att sammanfoga beteenden på ett modulärt och anpassningsbart sätt.

Förstå hur olika objekt kan dela ett gemensamt gränssnitt men ändå uppträda på sitt eget sätt. Detta avsnitt visar hur metodöverskuggning, gränssnitt och protokoll gör din kod mer dynamisk och återanvändbar.

Lär dig hur du skyddar intern data och kontrollerar åtkomst till klassattribut. Du kommer att utforska privata attribut, getters och setters samt tekniker för att dölja data som håller dina klasser säkra och underhållbara.

Grundprinciper för komposition