 |
| Quebra-Cabeça - Composição e Agregação em Delphi. |
Índice
Introdução
Na programação orientada a objetos, composição e agregação são dois conceitos fundamentais que descrevem como objetos podem ser relacionados uns aos outros. Entender a diferença entre esses dois conceitos e saber como implementá-los em Delphi é essencial para criar sistemas bem estruturados e manteníveis. Neste artigo, vamos explorar o que são composição e agregação, suas diferenças, e como implementá-las em Delphi com um exemplo prático.
Diferença entre Composição e Agregação em Delphi
Composição
A composição é uma forma de relação "tem-um" onde um objeto é parte integrante de outro objeto. Em outras palavras, quando o objeto "pai" é destruído, os objetos "filhos" também são destruídos. A composição implica uma relação de forte dependência.
Agregação
A agregação também é uma forma de relação "tem-um", mas ao contrário da composição, os objetos agregados podem existir independentemente do objeto "pai". Isso significa que a destruição do objeto "pai" não afeta a existência dos objetos agregados. A agregação implica uma relação de dependência mais fraca.
Como Implementar Composição e Agregação em Delphi
Implementando Composição
Para implementar a composição em Delphi, criamos uma classe "pai" que possui uma ou mais instâncias de outras classes "filhas" como parte de seus campos. Essas instâncias são criadas e destruídas pelo objeto "pai".
type
TBattery = class
private
FCharge: Integer;
public
constructor Create;
procedure ChargeBattery;
property Charge: Integer read FCharge write FCharge;
end;
TSmartphone = class
private
FBattery: TBattery;
public
constructor Create;
destructor Destroy; override;
procedure UsePhone;
property Battery: TBattery read FBattery;
end;
constructor TBattery.Create;
begin
FCharge := 100; // Bateria começa com carga total
end;
procedure TBattery.ChargeBattery;
begin
FCharge := 100;
end;
constructor TSmartphone.Create;
begin
FBattery := TBattery.Create; // Composição: bateria é parte integral do smartphone
end;
destructor TSmartphone.Destroy;
begin
FBattery.Free; // Libera a memória ocupada pela bateria
inherited;
end;
procedure TSmartphone.UsePhone;
begin
FBattery.Charge := FBattery.Charge - 10; // Usando o telefone, a bateria descarrega
end;
Implementando Agregação
Para implementar a agregação em Delphi, criamos uma classe "pai" que contém uma referência a uma ou mais instâncias de outras classes "filhas". Essas instâncias são passadas ao objeto "pai" de fora e não são criadas nem destruídas por ele.
type
TScreen = class
private
FResolution: string;
public
constructor Create(AResolution: string);
property Resolution: string read FResolution write FResolution;
end;
TLaptop = class
private
FScreen: TScreen;
public
constructor Create(AScreen: TScreen);
procedure ShowResolution;
property Screen: TScreen read FScreen write FScreen;
end;
constructor TScreen.Create(AResolution: string);
begin
FResolution := AResolution;
end;
constructor TLaptop.Create(AScreen: TScreen);
begin
FScreen := AScreen; // Agregação: a tela é passada para o laptop de fora
end;
procedure TLaptop.ShowResolution;
begin
WriteLn('Resolution: ', FScreen.Resolution);
end;
Exemplo Prático com Código
Vamos agora criar um exemplo prático que utiliza tanto composição quanto agregação para ilustrar esses conceitos.
Configurando o Ambiente
- Abrindo o Delphi: Abra o Delphi e crie um novo projeto VCL Forms Application
- Configurando o Formulário Principal: Adicione os seguintes componente ao formulário:
- TButton(Button1) - Caption Composição
- TButton(Button2) - Caption Agregação
Exemplo de Composição
Neste exemplo, um carro tem um motor. O motor é criado e destruído junto com o carro, exemplificando a composição.
type
TEngine = class
private
FPower: Integer;
public
constructor Create(APower: Integer);
property Power: Integer read FPower write FPower;
end;
TCar = class
private
FEngine: TEngine;
public
constructor Create(APower: Integer);
destructor Destroy; override;
procedure Drive;
property Engine: TEngine read FEngine;
end;
constructor TEngine.Create(APower: Integer);
begin
FPower := APower;
end;
constructor TCar.Create(APower: Integer);
begin
FEngine := TEngine.Create(APower); // Composição: motor é parte integral do carro
end;
destructor TCar.Destroy;
begin
FEngine.Free; // Libera a memória ocupada pelo motor
inherited;
end;
procedure TCar.Drive;
begin
ShowMessage('Driving with '+ IntToStr(FEngine.Power)+ ' horsepower');
end;
Utilizando a Classe TCar
Para utilizar a classe TCar, precisamos criar uma instância dela, passar a potência do motor como parâmetro e chamar o método Drive para simular a condução do carro.
procedure TForm1.Button1Click(Sender: TObject);
var
Car: TCar;
begin
Car := TCar.Create(150); // Cria um carro com um motor de 150 cavalos de potência
try
Car.Drive; // Simula a condução do carro
finally
Car.Free; // Libera a memória ocupada pelo carro
end;
end;
Exemplo de Agregação
Neste exemplo, uma equipe de desenvolvimento possui vários programadores. Os programadores são criados independentemente e podem ser adicionados ou removidos da equipe, exemplificando a agregação.
type
TProgrammer = class
private
FName: string;
public
constructor Create(AName: string);
property Name: string read FName write FName;
end;
TDevelopmentTeam = class
private
FProgrammers: TList<TProgrammer>;
public
constructor Create;
destructor Destroy; override;
procedure AddProgrammer(AProgrammer: TProgrammer);
procedure ShowTeam;
end;
constructor TProgrammer.Create(AName: string);
begin
FName := AName;
end;
constructor TDevelopmentTeam.Create;
begin
FProgrammers := TList<TProgrammer>.Create; // Cria a lista de programadores
end;
destructor TDevelopmentTeam.Destroy;
begin
FProgrammers.Free; // Libera a memória ocupada pela lista de programadores
inherited;
end;
procedure TDevelopmentTeam.AddProgrammer(AProgrammer: TProgrammer);
begin
FProgrammers.Add(AProgrammer); // Adiciona um programador à equipe
end;
procedure TDevelopmentTeam.ShowTeam;
var
Programmer: TProgrammer;
begin
for Programmer in FProgrammers do
ShowMessage('Programmer: '+ Programmer.Name);
end;
Utilizando a Classe TDevelopmentTeam
Para utilizar a classe TDevelopmentTeam, precisamos criar instâncias de TProgrammer, adicioná-las à equipe de desenvolvimento e, em seguida, exibir os membros da equipe.
procedure TForm1.Button2Click(Sender: TObject);
var
Team: TDevelopmentTeam;
Programmer1, Programmer2: TProgrammer;
begin
try
Team := TDevelopmentTeam.Create; // Cria uma nova equipe de desenvolvimento
try
Programmer1 := TProgrammer.Create('Alice');
Programmer2 := TProgrammer.Create('Bob');
Team.AddProgrammer(Programmer1); // Adiciona Alice à equipe
Team.AddProgrammer(Programmer2); // Adiciona Bob à equipe
Team.ShowTeam; // Exibe os membros da equipe
finally
Team.Free; // Libera a memória ocupada pela equipe
Programmer1.Free;//Libera a memória ocupada pelo programador 1
Programmer2.Free;//Libera a memória ocupada pelo programador 2
end;
except
on E: Exception do
ShowMessage(E.ClassName+ ': '+ E.Message);
end;
end;
O exemplo acima foi criado em uma única unit para ficar mais simples e didático, mas você pode melhorar esse projeto criando as classes de composição e agregação em units separadas para melhor organização e reaproveitamento do código.
Caso não saiba como criar e utilizar units veja o post a seguir: https://codedelphi.com/units-em-delphi/
Veja abaixo como ficou a ilustração do projeto utilizando Composição e Agregação:
.png) |
| Ilustração do projeto. |
Código fonte do exemplo
Você pode fazer o download do exemplo do projeto através do repositório do github:
https://github.com/Gisele-de-Melo/ComposicaoAgregacao
Conclusão
Neste artigo, exploramos os conceitos de composição e agregação em Delphi, destacando suas diferenças e como implementá-los. Vimos exemplos práticos de como criar e usar as classes TCar e TDevelopmentTeam, ilustrando como essas relações podem ser aplicadas em um projeto real.
Composição e agregação são ferramentas poderosas na programação orientada a objetos, permitindo uma estrutura clara e flexível para os sistemas que desenvolvemos. Compreender e aplicar corretamente esses conceitos ajudará você a criar códigos mais organizados e fáceis de manter, o que é essencial para o desenvolvimento de software de qualidade.
Nenhum comentário:
Postar um comentário