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

La composizione si concentra sulla costruzione di oggetti complessi combinando componenti più semplici e indipendenti. Invece di affidarsi all'ereditarietà, che crea gerarchie rigide, la composizione permette alle classi di collaborare tramite oggetti contenuti. Questo approccio rende i sistemi più **flessibili**, **modulari** e **facili da mantenere**, poiché i componenti possono essere sostituiti o estesi senza compromettere l'intera struttura.

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` non implementa direttamente la logica di pagamento, inventario o spedizione.
Invece, **possiede** oggetti separati (`Payment`, `Inventory`, `Shipping`) e li utilizza per svolgere il proprio lavoro.

Ogni componente ha una sola responsabilità e `Order` si limita a coordinarli.
Se si desidera cambiare il funzionamento del pagamento o della spedizione, è possibile sostituire il componente senza modificare la classe `Order`.


Alcuni rischi da considerare nell'uso della composizione sono la creazione di **god object** che raccolgono troppi componenti e diventano difficili da gestire, la **fuga delle API dei componenti** attraverso la classe esterna invece di mantenere un'interfaccia pulita, e l'introduzione di **accoppiamento nascosto** quando i componenti dipendono eccessivamente dai dettagli interni degli altri.

Un oggetto dio cerca di fare troppo. Contiene molti componenti e gestisce molte responsabilità, rendendo la classe difficile da comprendere, testare e mantenere.

Oggetti dio

Questo accade quando la classe esterna espone i metodi o gli attributi interni dei suoi componenti. Invece di fornire una propria interfaccia pulita, costringe gli utenti a interagire direttamente con gli oggetti interni.

API dei componenti esposte

I componenti diventano strettamente collegati tramite dettagli interni. Modificare una parte causa inaspettatamente la rottura di un'altra perché si basano sulla struttura interna reciproca invece che su contratti chiari.

Accoppiamento nascosto

Qual è un rischio comune nell'uso della composizione che può rendere il design più difficile da mantenere?

Impara a costruire applicazioni pulite, sicure e scalabili con la programmazione orientata agli oggetti in Python. Copri i fondamenti di classi e oggetti, per poi passare a concetti avanzati come ereditarietà, composizione, polimorfismo e incapsulamento. Con spiegazioni chiare ed esempi pratici, svilupperai la capacità di progettare programmi Python potenti, manutenibili e pronti per l'uso reale.

Apprendi i fondamenti della programmazione orientata agli oggetti in Python. Questa sezione tratta classi, oggetti, metodi e variabili, fornendo una solida base per comprendere come la OOP organizza e struttura il codice.

Esplora come le classi possano condividere ed estendere funzionalità. Verranno illustrati diversi modelli di ereditarietà, dalle gerarchie semplici all’ereditarietà multipla e alle classi astratte, mostrando come favoriscano il riutilizzo del codice e la scalabilità.

Scopri come costruire sistemi flessibili combinando oggetti. Invece di affidarti solo all'ereditarietà, vedrai come la composizione consenta di assemblare comportamenti in modo modulare e adattabile.

Comprendere come oggetti diversi possano condividere una stessa interfaccia pur mantenendo comportamenti distinti. Questa sezione illustra come l'override dei metodi, le interfacce e i protocolli rendano il codice più dinamico e riutilizzabile.

Scopri come proteggere i dati interni e controllare l'accesso agli attributi di classe. Verranno esplorati attributi privati, metodi getter e setter, e tecniche di occultamento dei dati che rendono le classi sicure e manutenibili.

Principi Fondamentali della Composizione