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

Composição concentra-se na construção de objetos complexos por meio da combinação de componentes mais simples e independentes. Em vez de depender de herança, que cria hierarquias rígidas, a composição permite que as classes colaborem por meio de objetos contidos. Essa abordagem torna os sistemas mais **flexíveis**, **modulares** e **fáceis de manter**, pois os componentes podem ser substituídos ou estendidos sem comprometer toda a estrutura.

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` não implementa a lógica de pagamento, estoque ou envio por conta própria.
Em vez disso, **possui** objetos separados (`Payment`, `Inventory`, `Shipping`) e os utiliza para realizar seu trabalho.

Cada componente tem uma responsabilidade, e `Order` apenas os coordena.
Se for necessário alterar como o pagamento ou o envio funcionam, é possível substituir o componente sem modificar a classe `Order`.


Alguns cuidados ao usar composição incluem evitar **objetos deus** que acumulam componentes demais e se tornam difíceis de gerenciar, **vazamento de APIs de componentes** pela classe externa em vez de manter uma interface limpa, e o surgimento de **acoplamento oculto** quando os componentes dependem excessivamente dos detalhes internos uns dos outros.


Um objeto deus tenta fazer demais. Ele contém muitos componentes e assume muitas responsabilidades, o que torna a classe difícil de entender, testar e manter.

Objetos deus

Isso ocorre quando a classe externa expõe os métodos ou atributos internos de seus componentes. Em vez de fornecer sua própria interface limpa, ela força os usuários a interagir diretamente com objetos internos.

Vazamento de APIs de componentes

Os componentes tornam-se fortemente conectados por meio de detalhes internos. Alterar uma parte quebra inesperadamente outra porque dependem da estrutura interna um do outro em vez de contratos claros.

Acoplamento oculto

Qual é um risco comum ao usar composição que pode tornar o design mais difícil de manter?

Aprenda a construir aplicações limpas, seguras e escaláveis com Programação Orientada a Objetos em Python. Aborde os fundamentos de classes e objetos, avançando para conceitos avançados como herança, composição, polimorfismo e encapsulamento. Com explicações claras e exemplos práticos, você desenvolverá a capacidade de projetar programas Python poderosos, manuteníveis e prontos para uso no mundo real.

Aprenda os principais fundamentos da programação orientada a objetos em Python. Esta seção aborda classes, objetos, métodos e variáveis, proporcionando uma base sólida para compreender como a OOP organiza e estrutura o código.

Explore como as classes podem compartilhar e estender funcionalidades. Você aprenderá diferentes padrões de herança, desde hierarquias simples até herança múltipla e classes abstratas, e verá como eles possibilitam o reuso de código e a escalabilidade.

Descubra como construir sistemas flexíveis combinando objetos. Em vez de depender apenas de herança, veja como a composição permite montar comportamentos de forma modular e adaptável.

Compreenda como diferentes objetos podem compartilhar uma interface comum enquanto apresentam comportamentos distintos. Esta seção demonstra como a sobrescrita de métodos, interfaces e protocolos tornam seu código mais dinâmico e reutilizável.

Aprenda a proteger dados internos e controlar o acesso aos atributos de classe. Serão explorados atributos privados, métodos getters e setters, e técnicas de ocultação de dados que mantêm suas classes seguras e fáceis de manter.

Princípios Fundamentais da Composição