 |
| Interface Delphi. |
Índices
Introdução
Nesse post iremos abordar sobre a utilização de Interfaces em Delphi, vantagens de uso, declaração, implementação e código fonte completo.
Entendendo e Utilizando em Seus Projetos
Diferença entre Classes Abstratas e Interfaces
No desenvolvimento de software, as interfaces e classes abstratas são conceitos fundamentais que ajudam a definir contratos e comportamentos esperados das classes. Embora ambas sejam usadas para definir métodos que devem ser implementados por classes derivadas, elas têm diferenças importantes:
- Classes Abstratas: São classes que não podem ser instanciadas diretamente. Elas podem conter métodos abstratos (sem implementação) e métodos concretos (com implementação). Uma classe abstrata pode herdar de outra classe e implementar métodos.
- Interfaces: São contratos puros que definem um conjunto de métodos sem qualquer implementação. Uma classe que implementa uma interface deve fornecer a implementação de todos os métodos definidos na interface. As interfaces não podem conter nenhum código, apenas declarações de métodos.
Como Declarar e Implementar Interfaces em Delphi
Declarando uma Interface
Em Delphi, uma interface é declarada usando a palavra-chave interface. Aqui está um exemplo de como declarar uma interface:
type
ICalculadora = interface
['{D3E9D48C-52FE-4C82-9F1C-3D7F3CDBD8B1}']
function Somar(a, b: Integer): Integer;
function Subtrair(a, b: Integer): Integer;
function Multiplicar(a, b: Integer): Integer;
function Dividir(a, b: Integer): Double;
end;
Implementando uma Interface
Para implementar uma interface, uma classe deve declarar que implementa essa interface e fornecer implementações para todos os métodos definidos na interface:
type
TCalculadora = class(TInterfacedObject, ICalculadora)
public
function Somar(a, b: Integer): Integer;
function Subtrair(a, b: Integer): Integer;
function Multiplicar(a, b: Integer): Integer;
function Dividir(a, b: Integer): Double;
end;
implementation
function TCalculadora.Somar(a, b: Integer): Integer;
begin
Result := a + b;
end;
function TCalculadora.Subtrair(a, b: Integer): Integer;
begin
Result := a - b;
end;
function TCalculadora.Multiplicar(a, b: Integer): Integer;
begin
Result := a * b;
end;
function TCalculadora.Dividir(a, b: Integer): Double;
begin
if b = 0 then
raise Exception.Create('Divisão por zero não é permitida');
Result := a / b;
end;
Vantagens do Uso de Interfaces
O uso de interfaces em Delphi traz várias vantagens para o desenvolvimento de software, incluindo:
- Desacoplamento: Interfaces permitem que o código seja mais modular e menos dependente das implementações concretas. Isso facilita a manutenção e a evolução do software.
- Flexibilidade: Com interfaces, é possível trocar implementações facilmente sem alterar o código que usa a interface. Isso é útil, por exemplo, ao mudar de um banco de dados para outro ou ao substituir um algoritmo por uma versão mais eficiente.
- Reutilização de Código: Interfaces permitem que diferentes classes implementem o mesmo conjunto de métodos, promovendo a reutilização de código e reduzindo a duplicação.
- Teste e Mocking: Interfaces facilitam a criação de mocks para testes unitários, permitindo que as dependências sejam substituídas por versões simuladas.
Exemplo Prático com Código
Vamos criar um exemplo prático de uma aplicação Delphi que usa interfaces para definir e implementar uma calculadora simples.
Passo 1: Definindo a Interface
Primeiro, vamos definir a interface ICalculadora conforme mostrado anteriormente.
Passo 2: Implementando a Interface
Em seguida, implementamos a interface na classe TCalculadora.
Passo 3: Utilizando a Interface
Agora, vamos criar um formulário que utiliza a interface ICalculadora para realizar operações matemáticas.
- Crie um novo projeto VCL Forms Application no Delphi.
- Adicione um
TEditpara cada um dos números de entrada (dois no total). - Adicione botões para cada operação matemática (Somar, Subtrair, Multiplicar, Dividir).
- Adicione um
TLabelpara exibir o resultado.
No código do formulário, usaremos a interface ICalculadora para realizar as operações:
unit Unit1;
interface
uses
Vcl.Forms, Vcl.Controls, Vcl.StdCtrls, System.SysUtils, System.Classes;
type
//Interface ICalculadora
ICalculadora = interface
['{D3E9D48C-52FE-4C82-9F1C-3D7F3CDBD8B1}']//Assinatura da classe, para gerar essa linha basta apertar as teclas Shift + Ctrl + G
function Somar(a, b: Integer): Integer; //Declaração do método Somar
function Subtrair(a, b: Integer): Integer; //Declaração do método Subtrair
function Multiplicar(a, b: Integer): Integer; //Declaração do método Multiplicar
function Dividir(a, b: Integer): Double; //Declaração do método Dividir
end;
//Classe TCalculadora que implementa a interface ICalculadora
TCalculadora = class(TInterfacedObject, ICalculadora)
public
function Somar(a, b: Integer): Integer; //Implementação do método Somar
function Subtrair(a, b: Integer): Integer; //Implementação do método Subtrair
function Multiplicar(a, b: Integer): Integer; //Implementação do método Multiplicar
function Dividir(a, b: Integer): Double; //Implementação do método Dividir
end;
//Classe do formulário
TForm1 = class(TForm)
EditNum1: TEdit;
EditNum2: TEdit;
BtnSomar: TButton;
BtnSubtrair: TButton;
BtnMultiplicar: TButton;
BtnDividir: TButton;
LabelResultado: TLabel;
procedure BtnSomarClick(Sender: TObject);
procedure BtnSubtrairClick(Sender: TObject);
procedure BtnMultiplicarClick(Sender: TObject);
procedure BtnDividirClick(Sender: TObject);
private
Calculadora: ICalculadora;
public
constructor Create(AOwner: TComponent); override;
end;
var
Form1: TForm1;
implementation
{$R *.dfm}
{ TCalculadora }
function TCalculadora.Somar(a, b: Integer): Integer;
begin
Result := a + b;
end;
function TCalculadora.Subtrair(a, b: Integer): Integer;
begin
Result := a - b;
end;
function TCalculadora.Multiplicar(a, b: Integer): Integer;
begin
Result := a * b;
end;
function TCalculadora.Dividir(a, b: Integer): Double;
begin
if b = 0 then
raise Exception.Create('Divisão por zero não é permitida');
Result := a / b;
end;
{ TForm1 }
constructor TForm1.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
Calculadora := TCalculadora.Create;
end;
procedure TForm1.BtnSomarClick(Sender: TObject);
var
Num1, Num2: Integer;
begin
Num1 := StrToInt(EditNum1.Text);
Num2 := StrToInt(EditNum2.Text);
LabelResultado.Caption := 'Resultado: ' + IntToStr(Calculadora.Somar(Num1, Num2));
end;
procedure TForm1.BtnSubtrairClick(Sender: TObject);
var
Num1, Num2: Integer;
begin
Num1 := StrToInt(EditNum1.Text);
Num2 := StrToInt(EditNum2.Text);
LabelResultado.Caption := 'Resultado: ' + IntToStr(Calculadora.Subtrair(Num1, Num2));
end;
procedure TForm1.BtnMultiplicarClick(Sender: TObject);
var
Num1, Num2: Integer;
begin
Num1 := StrToInt(EditNum1.Text);
Num2 := StrToInt(EditNum2.Text);
LabelResultado.Caption := 'Resultado: ' + IntToStr(Calculadora.Multiplicar(Num1, Num2));
end;
procedure TForm1.BtnDividirClick(Sender: TObject);
var
Num1, Num2: Integer;
begin
Num1 := StrToInt(EditNum1.Text);
Num2 := StrToInt(EditNum2.Text);
LabelResultado.Caption := 'Resultado: ' + FloatToStr(Calculadora.Dividir(Num1, Num2));
end;
end.
Veja abaixo como ficou a ilustração do projeto utilizando Interfaces:
 |
| 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/Interface
Conclusão
O uso de interfaces em Delphi é uma prática poderosa que traz muitos benefícios para o desenvolvimento de software. Elas promovem o desacoplamento, a flexibilidade e a reutilização de código, além de facilitar o teste de software. Com este guia, você aprendeu a diferença entre classes abstratas e interfaces, como declarar e implementar interfaces, e as vantagens de usar interfaces em seus projetos. O exemplo prático fornecido demonstrou como aplicar esses conceitos em uma aplicação real. Continue explorando e aplicando interfaces em seus projetos para criar software mais modular e sustentável.
Nenhum comentário:
Postar um comentário