Interfaces: Aprofundamento - Revista Clube Delphi 136

O artigo trata de interfaces, uma maneira de se estabelecer um “contrato” entre duas entidades, sejam eles objetos, componentes ou outros programas, de modo que possam se comunicar através de trocas de mensagens que nada mais são do que chamadas

ClubeDelphi 136

[Artigo já está disponível no Leitor Digital DevMedia®. Clique aqui para acessá-lo]

> Clique aqui para ler todos os artigos da ClubeDelphi 136

No artigo anterior, Interfaces – Teoria e Prática, foi explorada a teoria sobre interfaces. Foram apresentadas características das mesmas, como declará-las e usá-las em Delphi e ainda foi mostrado sobre as GUIDs.

Também foi apresentada a agregação, mostrando como um objeto pode implementar várias interfaces simulando herança múltipla ou como um objeto pode implementar uma interface e conter uma referência para outro que implemente outra interface. Foram feitas algumas experiências com veículos e animais. Outro ponto interessante para ser mostrado sobre as interfaces é a contagem de referências. Neste artigo daremos continuidade ao assunto explorando sobre como utilizar herança com interfaces e como manter referências de forma correta.

Interfaces com propriedades

Considere-se a interface ICliente da Listagem 1.

Listagem 1. Interface ICliente

unit uICliente;

interface

type

ICliente = interface

[''{3A192476-2CF2-4895-8B97-7DED7A8EC181}'']

procedure SetNome(const vNome: string);

procedure SetCPF(const vCPF: string);

procedure SetDtNasc(const vDtNasc: TDateTime);

procedure SetEndereco(const vEndereco: string);

function GetNome: string;

function GetCPF: string;

function GetDtNasc: TDateTime;

function GetEndereco: string;

property Nome: string read GetNome write SetNome;

property CPF: string read GetCPF write SetCPF;

property DtNasc: TDateTime read GetDtNasc write SetDtNasc;

property Endereco: string read GetEndereco write SetEndereco;

end;

implementation

end.

Interfaces podem ter propriedades, contanto que elas estejam configuradas com métodos acessores que também façam parte da interface. Como consequência, os métodos acessores deverão ser públicos na implementação da interface, pois todos os métodos de uma interface devem ser implementados como públicos.

Isso não é uma consequência ruim. Os métodos acessores públicos podem ser usados de igual forma ao Java ou C++: invocando o acessor Set para mudar o valor de um atributo ou o acessor Get para obter o valor do atributo. Mesmo assim, há vantagem de usar uma propriedade diretamente em vez dos assessores. Propriedades que escrevem ou leem seus valores diretamente nos campos privados podem constituir uma violação de encapsulamento. Entretanto, em alguns casos, permite-se a leitura direta e a escrita usando-se um método acessor. Cada caso é um caso e a própria VCL tem muitos exemplos de classes e componentes com propriedades que leem ou escrevem diretamente de campos privados.

Também não é nenhum crime expor os campos se eles forem realmente atributos relevantes da entidade que precisam ser vistos e modificados pelo ambiente externo, contanto que não haja uma maneira especial de se ler ou gravar esses atributos.

Sempre que houver uma maneira especial de se ler ou gravar esses atributos, como cálculos, validações ou máscaras, sempre é possível encapsular este atributo com métodos acessores e vincular esses acessores a uma propriedade, permanecendo o acesso ao atributo transparente.

Implementação de interfaces

A interface ICliente da Listagem 1 contém uma propriedade chamada CPF dando a entender que o cliente sempre será uma pessoa física. Isso poderia ser feito de outra forma, a propriedade poderia se chamar Documento e classes diferentes de pessoa física ou jurídica implementariam esta mesma interface. Uma classe que pode implementar a interface ICliente é a classe TCliente da Listagem 2.

Listagem 2. Classe TCliente

type

TCliente = class(TInterfacedObject, ICliente)

private

FNome: string;

FEndereco: string;

FCPF: string;

FDtNasc: TDateTime;

public

procedure SetNome(const vNome: string);

procedure SetCPF(const vCPF: string);

procedure SetDtNasc(const vDtNasc: TDateTime);