Fala Radizeiros e Radizeiras, tudo bem com vocês?

Nos dias de hoje, a tecnologia muda constantemente, é de extrema importância que tenhamos códigos de fácil manutenção, e claro, mais escalável, para que consiga se adaptar às mudanças sem ferir as suas regras de negócios.

E você hoje pode estar se perguntando como aplicar o uso das interfaces, e claro, o POO, nos seu projeto hoje?

A grosso modo, é possível trocar a roda com o carro andando.

Te digo que isso é possível com essas aplicabilidades, e claro, uma boa refatoração.

Com os conhecimentos que tenho mostrado aqui para vocês, tenho total certeza que levará suas aplicações para um outro nível.

E como foi dito, como trabalhar as regras de negócios do meu software usando essas metodologias.

No post de hoje estarei mostrando como trocar as regras sem mexer nas suas interfaces.

Nos posts anteriores você já aprendeu a criar suas interfaces.

E qual é o grande benefício da utilização das interfaces?

O benefício se dá pelo fato de poder substituir o objeto sem mexer na sua interface.

No código abaixo, você tem uma classe que implementa uma interface.

TModelPessoa = class(TInterfacedObject, iPessoa)
private
FNome : String;
FSobreNome : String;
public
constructor Create;
destructor Destroy; override;
class function New : iPessoa;
function Nome(Value : String) : iPessoa;
function SobreNome(Value : String) : iPessoa;
function NomeCompleto : String;
end;

Irei refatorar ela para TModelPessoaFisica.

Agora essa nossa classe está se referindo a pessoa física.

Agora que já temos a classe de pessoa física criada, vamos criar uma classe para pessoa jurídica.

type
TModelPessoaJuridica = class(TInterfacedObject, iPessoa)
private
FNome : String;
FSobreNome : String;
public
constructor Create;
destructor Destroy; override;
class function New : iPessoa;
function Nome(Value : String) : iPessoa;
function SobreNome(Value : String) : iPessoa;

function NomeCompleto : String;

end;

implementation

constructor TModelPessoaJuridica.Create;
begin

end;

destructor TModelPessoaJuridica.Destroy;
begin
inherited;
end;

class function TModelPessoaJuridica.New : iPessoa;
begin
Result := Self.Create;
end;

function TModelPessoaJuridica.Nome(Value: String): iPessoa;
begin
Result := Self;
FNome := Value;
end;

function TModelPessoaJuridica.NomeCompleto: String;
begin
Result := FNome +' '+ FSobreNome +' LTDA ME';
end;

function TModelPessoaJuridica.SobreNome(Value: String): iPessoa;
begin
Result := Self;
FSobreNome := Value;
end;

Observe que criamos a mesma estrutura de classe, e está utilizando da mesma interface.

E a única diferença que foi feita é que ao retornar o nome completo eu acrescentei o LTDA ME no final, só para podermos diferenciar.

Como você pode observar, as duas implementam a mesma interface de pessoa.

Iremos mexer um pouco no código para que fique nítido essa utilização.

Vamos fazer uma utilização simples.

A primeira utilização simples que podemos fazer é o seguinte.

Vamos criar na nossa view uma variável chamada FPessoa do tipo iPessoa.

...
private
FPessoa : iPessoa;
...

Observe que o tipo dessa nossa variável é de uma interface, e não do tipo de uma classe.

As boas práticas da programação dizem que nós temos que programar orientado a interface, e não orientada a classe.

Quando eu chamei iPessoa, estou dizendo que irei utilizar a interface, não me importa no que está sendo feito internamente, mas sei utilizar a interface.

Lembrando que a interface não existe sem uma classe concreta.

Então simplesmente eu irei instanciar esse meu objeto da minha classe TPessoaFisica;

procedure TForm1.FormCreate(Sender: TObject);
begin
FPessoa := TModelPessoaFisica.New;
end;

Estou dizendo agora que a interface pessoa tem um motor para ela funcionar, eu irei substituir a implementação criada no post anterior.

procedure TForm1.Button1Click(Sender: TObject);
begin
Memo1.Lines.Text :=
FPessoa
.Nome(Edit1.Text)
.SobreNome(Edit2.Text)
.NomeCompleto;
end;

Vamos rodar nosso projeto agora novamente.

Observe que permanece tudo funcionando normalmente.

Isso se dá pelo fato de que o motor dessa interface é a pessoa física.

Nossa variável utiliza uma interface, ela não é uma classe, como falei anteriormente.

E ao instanciar esse objeto, simplesmente instância da classe de pessoa física.

E o código que alteramos está funcionando porque está utilizando o objeto FPessoa.

Agora se eu alterar a instância para pessoa jurídica?

procedure TForm1.FormCreate(Sender: TObject);
begin
FPessoa := TModelPessoaJuridica.New;
end;

Observe que eu troquei somente a instância.

Não precisei mexer na implementação anterior do botão.

Eu não preciso mexer na implementação do botão.

Não precisei mexer porque ele está implementando a interface, simplesmente eu altero a instância do objeto.

Eu não preciso refatorar, só alterar as implementações do objeto e todo o meu sistema, que implementa essa interface irá executar a regra de negócio que é implementada nessa classe.

E caso você tem interesse de conhecer mais sobre Dominando Interfaces na Orientação a Objetos, acesse o nosso portal do CLUBE DE PROGRAMADORES EM DELPHI.

Você não terá só conteúdos relacionados ao Dominando Interfaces na Orientação a Objetos, mas uma quantidade enorme de conteúdos que poderá lhe ajudar muito no seu dia a dia, é uma verdadeira NETFLIX para os programadores Delphi.

CLIQUE AQUI E SAIBA MAIS SOBRE O CLUBE DOS PROGRAMADORES DELPHI