Fala Radizeiro e Radizeira, tudo bem com vocês?

Compreender o conceito de interfaces na programação orientada a objetos é muito importante.

Quando você consegue compreender e ter um certo domínio sobre o assunto, com toda certeza você verá os grandes benefícios na sua utilização.

O desacoplamento de códigos é de extrema importância na questão da usabilidade do seu código, onde você consegue ter uma melhor e mais rápida manutenção.

E primeira coisa que você tem que fazer para usar as interface é criar uma unit separada dos formulários.

Isso mesmo, você terá uma unit para cada regra, isso lhe dará maior flexibilidade na manutenção e atualização de rotinas.

Nesse nosso exemplo irei adicionar uma nova unit, onde irei criar um interface chamada iPessoa.

iPessoa = interface
function Nome(Value : String) : iPessoa;
function SobreNome(Value : String) : iPessoa;
function NomeCompleto : String;
end;

Você pode estar se perguntando, o que é esse negócio de interface?

Vamos pensar nas interfaces no menu do micro-ondas, onde nela você irá colocar as funcionalidades que você quer que uma pessoa tenha, independente do que será feito internamente no código.

Observe que dentro da nossa interface eu criei um método que retorna a própria interface.

Esse procedimento é uma padrão de projeto chamado Fluent Interface.

Toda classe que implementar essa interface irá precisar utilizar esse métodos que acabamos de criar.

Ao colocar o retorno do método o mesmo nome da interface, isso me dá possibilidade de ao colocar um ponto no final de sua implementação poder chamar outros métodos que compõem essa interface.

Mas iremos ver de verdade os seus benefícios.

Vamos implementar agora uma classe TPessoa, que implementa essa interface?

type
TModePessoa = 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 TModePessoa.Create;
begin

end;

destructor TModePessoa.Destroy;
begin
inherited;
end;

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

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

function TModePessoa.NomeCompleto: String;
begin
Result := FNome +' '+ FSobreNome;
end;

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

Observe a classe que implementa a interface, onde na hora da herança nós definimos o que iremos implementar.

Se você for usar uma interface diretamente, você irá precisar ter três métodos específicos, e quais os benefícios que ele traz para você.

Esses três métodos em especifico são: QueryInterface, _AddRef, e o _Release.

Se você não quer implementar esses três métodos, o Delphi já possui uma classe específica que pode lhe ajudar na implementação desses três métodos, que é o TInterfacedObject.

Essa classe já implementa esses três métodos necessários que você precisa para utilizar interfaces.

Logo após, como pode ver no código acima, eu adicionei essa minha interface iPessoa, que criei anteriormente.

Ao passar a interface, sem fazer mais nada, e tentar compilar, o Delphi irá reclamar a falta da implementação dos métodos dessa interface.

Todas as vezes que você implementar um interface, ele irá te obrigar a implementar os métodos declarados nele.

Se não tiver esses métodos, você não está implementando a interface.

Quando trabalhamos com interfaces assumimos o uso dos métodos que estão assinados nela.

Nesse processo, muitos dão como referência a interface como se ela fosse um contrato, onde você assina um contrato, e esse contrato possui as cláusulas.

Desta forma vocês estão assumindo a responsabilidade de seguir o que esse contrato diz, assim é o uso das interfaces, e seus métodos são as clausuras.

Esse é um bom exemplo para ilustrar a utilização de interfaces dentro do Delphi.

Dentro do método Destroy, pois como trabalhamos com Interface, ele utiliza o ARC, que é o Automatic Reference Count, onde o Delphi faz o controle automaticamente das instâncias para nós.

Quando o objeto sai do seu funcionamento, ele simplesmente é limpo da memória sem que venhamos destruir ele manualmente.

Para que possamos trabalhar com as informações dentro dessa nossa classe, que serão passados pelos nossos métodos, criamos algumas variáveis.

Em cada método passamos os valores recebidos por parâmetro para essas variáveis para que possamos utilizar as mesmas como retorno no método NomeCompleto.

Mas você pode observar que dentro desses métodos que retorna a interface, eu coloquei um Result := Self, isso está sendo referenciado a classe,e como essa classe está trabalhando com a herança da interface, ele recebe esse Self.

Desta forma já possuímos nossa classe de TPessoa herdando de uma interface, e com todos seus métodos já implementados.

Bem prático e simples sua implementação não é verdade?

Quando você começar a utilizar esses conceitos no seu dia a dia, irá ter maior controle e redução de acoplamentos.

Se ainda não conhece a utilização de interfaces na orientação a objetos, e deseja saber mais, basta acessar o link e conhecer o CLUBE DOS PROGRAMADORES DELPHI.

O maior portal de conteúdo Delphi da atualidade, onde você encontrará diversos assuntos voltados para o universo Delphi.

Esse conteúdo completo e muitos outros você pode encontrar dentro do CLUBE DOS PROGRAMADORES DELPHI.

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