POO 2.6: composição, agregação e associação

Introdução

Neste capítulo, vamos abordar três conceitos fundamentais das relações entre objetos na Programação Orientada a Objetos (POO): Associação, Composição e Agregação. Entender essas relações é essencial para construir sistemas bem estruturados e flexíveis.

Definições

Em termos de vínculo e controle de existência, temos:

• Composição: Uma forma forte de associação, onde o “todo” é dono de seus componentes. Se o “todo” for destruído, os componentes também são. Exemplo: Uma casa é composta por cômodos. Se a casa for destruída, os cômodos também são.
• Agregação: Uma forma moderada de associação. Os objetos estão relacionados, mas vivem independentemente. O “todo” conhece suas “partes”, mas não controla sua existência. Exemplo: Um cliente tem pedidos, mas os pedidos podem existir fora do cliente. Não há destruição automática das partes.
• Associação: A forma mais fraca de relacionamento entre objetos. Apenas uma ligação sem controle de ciclo de vida. Apenas um relacionamento genérico entre objetos. Exemplo: Um médico está associado a um hospital, mas nenhum depende do outro para existir. Pode ser unidirecional ou bidirecional.

Exemplo Prático: Sistema de Pedidos

1. Associação: Um vendedor pode atender vários pedidos, mas o pedido e o vendedor podem existir separadamente.
2. Composição: Um pedido é composto por itens. Se o pedido for destruído, os itens também serão.
3. Agregação: Um cliente pode ter pedidos, mas os pedidos não são destruídos junto com o cliente.

Código do Exemplo

Definindo as Classes Básicas (Pedido e Itens)

type
  TItemPedido = class
  private
    FDescricao: string;
    FQuantidade: Integer;
  public
    property Descricao: string read FDescricao write FDescricao;
    property Quantidade: Integer read FQuantidade write FQuantidade;
  end;

  TPedido = class
  private
    FItens: TObjectList<TItemPedido>;
  public
    constructor Create;
    destructor Destroy; override;
    procedure AdicionarItem(const ADescricao: string; AQuantidade: Integer);
  end;

constructor TPedido.Create;
begin
  inherited Create;
  FItens := TObjectList<TItemPedido>.Create(True); // composição: TPedido é dono dos itens
end;

destructor TPedido.Destroy;
begin
  FItens.Free;
  inherited;
end;

procedure TPedido.AdicionarItem(const ADescricao: string; AQuantidade: Integer);
var
  Item: TItemPedido;
begin
  Item := TItemPedido.Create;
  Item.Descricao := ADescricao;
  Item.Quantidade := AQuantidade;
  FItens.Add(Item);
end;

Classe Cliente (Agregação)

type
  TCliente = class
  private
    FNome: string;
    FPedidos: TList<TPedido>; // agregação: cliente não é dono dos pedidos
  public
    constructor Create;
    destructor Destroy; override;
    procedure AdicionarPedido(Pedido: TPedido);
    property Nome: string read FNome write FNome;
  end;

constructor TCliente.Create;
begin
  inherited Create;
  FPedidos := TList<TPedido>.Create;
end;

destructor TCliente.Destroy;
begin
  FPedidos.Free;
  inherited;
end;

procedure TCliente.AdicionarPedido(Pedido: TPedido);
begin
  FPedidos.Add(Pedido);
end;

Classe Vendedor (Associação)

type
  TVendedor = class
  private
    FNome: string;
  public
    property Nome: string read FNome write FNome;
  end;

Exemplo de Uso

var
  Cliente: TCliente;
  Pedido: TPedido;
  Vendedor: TVendedor;
begin
  Cliente := TCliente.Create;
  Cliente.Nome := 'João';

  Pedido := TPedido.Create;
  Pedido.AdicionarItem('Mouse', 2);
  Pedido.AdicionarItem('Teclado', 1);

  Cliente.AdicionarPedido(Pedido); // agregação

  Vendedor := TVendedor.Create;
  Vendedor.Nome := 'Carlos';
  // associação simples: vendedor não é dono nem do cliente, nem do pedido

  // Liberação dos objetos
  Vendedor.Free;
  Pedido.Free;
  Cliente.Free;
end;