Olá Galera, vamos ver neste artigo um pouco sobre classes. Vou mostrar como criar uma classe do zero, e explicar o que o Delphi faz quando usamos CTRL + SHIF + C (comando para implementar as propriedades e métodos de uma determinada classe).
Inicialmente vamos criar uma Classe chamada de TCliente e para isso criarmos uma unit chamada uCliente.pas:
unit uCliente;
interface
implementation
end.
Criação da classe
Veja no código abaixo como vamos criar a classe no Delphi.
unit uCliente;
interface
Type
TCliente = class
private
protected
public
published
end;
implementation
end.
Criaremos agora as propriedades básicas da Classe TCliente: ID, Nome, Sexo, CPF, RG, Telefone, Endereco, Bairro, Cidade, CEP. Veja o código como ficará:
unit uCliente;
interface
Type
TCliente = class
private
protected
public
published
end;
implementation
end.
Vamos criar as propriedades básicas da Classe TCliente: ID, Nome, Sexo, CPF, RG, Telefone, Endereco, Bairro, Cidade, CEP. Veja o código como ficará:
unit uCliente;
interface
Type
TCliente = class
private
protected
public
property ID :String;
property Nome :String;
property Sexo :String;
property CPF :String;
property RG :String;
property Telefone :String;
property Endereco :String;
property Bairro :String;
property Cidade :String;
property CEP :String;
published
end;
implementation
end.
Ao final da digitação da property CEP: String usaremos a combinação de teclas CTRL + SHIFT + C para implementar a classe.
Seu código agora modificará complementamente, incluindo várias procedures e Fields. Vamos analisar como ficou o código.
unit uCliente;
interface
Type
TCliente = class
private
FNome: String;
FBairro: String;
FCEP: String;
FID: String;
FCPF: String;
FSexo: String;
FCidade: String;
FEndereco: String;
FTelefone: String;
FRG: String;
procedure SetBairro(const Value: String);
procedure SetCEP(const Value: String);
procedure SetCidade(const Value: String);
procedure SetCPF(const Value: String);
procedure SetEndereco(const Value: String);
procedure SetID(const Value: String);
procedure SetNome(const Value: String);
procedure SetRG(const Value: String);
procedure SetSexo(const Value: String);
procedure SetTelefone(const Value: String);
protected
public
property ID :String read FID write SetID;
property Nome :String read FNome write SetNome;
property Sexo :String read FSexo write SetSexo;
property CPF :String read FCPF write SetCPF;
property RG :String read FRG write SetRG;
property Telefone :String read FTelefone write SetTelefone;
property Endereco :String read FEndereco write SetEndereco;
property Bairro :String read FBairro write SetBairro;
property Cidade :String read FCidade write SetCidade;
property CEP :String read FCEP write SetCEP;
published
end;
implementation
{ TCliente }
procedure TCliente.SetBairro(const Value: String);
begin
FBairro := Value;
end;
procedure TCliente.SetCEP(const Value: String);
begin
FCEP := Value;
end;
procedure TCliente.SetCidade(const Value: String);
begin
FCidade := Value;
end;
procedure TCliente.SetCPF(const Value: String);
begin
FCPF := Value;
end;
procedure TCliente.SetEndereco(const Value: String);
begin
FEndereco := Value;
end;
procedure TCliente.SetID(const Value: String);
begin
FID := Value;
end;
procedure TCliente.SetNome(const Value: String);
begin
FNome := Value;
end;
procedure TCliente.SetRG(const Value: String);
begin
FRG := Value;
end;
procedure TCliente.SetSexo(const Value: String);
begin
FSexo := Value;
end;
procedure TCliente.SetTelefone(const Value: String);
begin
FTelefone := Value;
end;
end.
O que houve?
Para cada property criada, por exemplo: property ID :String, o Delphi criou dois métodos de leitura(Read) e escrita(Write): property ID :String read FID write SetID;, onde:
- FID = Field para armazenar o valor passado para propriedade;
- SetID = Procedure para validar por exemplo um ID já existe, ou então se o CPF é válido, e logo em seguida atribuir o conteúdo informado para o Field FID, veja como o Delphi implementa o SetID.
procedure TCliente.SetID(const Value: String);
begin
FID := Value;
end;
Com este método o parâmetro Const (não pode ser alterado dentro do método) Value contém o valor informado quando usamos, por exemplo:
Procedure TFrmCliente.Novo;
begin
Cliente.ID := 1;
End;
Sendo assim, o que este método SetID faz simplesmente é armazenar o Value em FID, como a linha abaixo mostra:
FID := Value
O código fica bem grande, dando a entender que fizemos muitas implementações e tudo mais. Contudo, fizemos alguma validação com os campos? Fizemos alguma regra de negocio? NÃO!
Vamos implementar uma regra básica para entendermos como fazer e depois adaptar. Supondo que gostaríamos de validar a quantidade de caracteres de um CPF, contando os pontos e traço. Sendo assim, teríamos 14 caracteres, como exemplo: 123.456.789-01.
Usando a função Length encontrada na unit System podemos ver o tamanho de uma string. No código verificamos se foi informado 14 caracteres ou não:
procedure TCliente.SetCPF(const Value: String);
begin
If Length(Value) = 14 Then
FCPF := Value
else
raise Exception.Create('CPF inválido, número de caracteres maior ou menor que 14');
//Para usar o Exception devemos dar uses em SysUtils;
end;
Com isso temos uma suposta regra de negócios, onde o CPF tem que 14 caracteres, nem a mais, nem a menos.
Voltando então a pergunta inicial, temos regras de negócio nesta nossa classe de Cliente? Inicialmente não, então não precisamos ter procedures SetID, SetNome, SetCPF, Set... O que vou fazer é bem simples, mas requer muita atenção: inicialmente vamos apagar todas as procedures declaradas e implementadas. Feito isso seu código ficará assim:
unit uCliente;
interface
uses SysUtils;
Type
TCliente = class
private
FNome: String;
FBairro: String;
FCEP: String;
FID: String;
FCPF: String;
FSexo: String;
FCidade: String;
FEndereco: String;
FTelefone: String;
FRG: String;
{REMOVEMOS AS DECLARAÇÕES DAS PROCEDURES DAQUI }
protected
public
property ID :String read FID write SetID;
property Nome :String read FNome write SetNome;
property Sexo :String read FSexo write SetSexo;
property CPF :String read FCPF write SetCPF;
property RG :String read FRG write SetRG;
property Telefone :String read FTelefone write SetTelefone;
property Endereco :String read FEndereco write SetEndereco;
property Bairro :String read FBairro write SetBairro;
property Cidade :String read FCidade write SetCidade;
property CEP :String read FCEP write SetCEP;
published
end;
implementation
{REMOVEMOS AS IMPLEMENTAÇÕES DAS PROCEDURES DAQUI }
end.
Já está pronto? Não!! Falta agora remover o método de escrita(Write) nas propertys e modificar para escrever diretamente nos Fields, mas como assim? Veja abaixo o código:
unit uCliente;
interface
Type
TCliente = class
private
FNome: String;
FBairro: String;
FCEP: String;
FID: String;
FCPF: String;
FSexo: String;
FCidade: String;
FEndereco: String;
FTelefone: String;
FRG: String;
protected
public
{Observe que onde esta SetID, SetNome, Set... Foi modificado agora para FID, FNome,F...}
property ID :String read FID write FID;
property Nome :String read FNome write FNome;
property Sexo :String read FSexo write FSexo;
property CPF :String read FCPF write FCPF;
property RG :String read FRG write FRG;
property Telefone :String read FTelefone write FTelefone;
property Endereco :String read FEndereco write FEndereco;
property Bairro :String read FBairro write FBairro;
property Cidade :String read FCidade write FCidade;
property CEP :String read FCEP write FCEP;
published
end;
implementation
end.
Como vocês podem ver a Unit fica mais limpa, a classe fica bem mais simples de se visualizar e dar manutenção. Agora atenção: isso é se você não tiver regras de negócio para suas propertys ok? Caso tenha, crie a procedure, associe-a ao Write da property e implemente-a com sua regra de negócio. Ficará então da seguinte forma:
unit uCliente;
interface
uses SysUtils;
Type
TCliente = class
private
FNome: String;
FBairro: String;
FCEP: String;
FID: String;
FCPF: String;
FSexo: String;
FCidade: String;
FEndereco: String;
FTelefone: String;
FRG: String;
{Metodo de validação do CPF}
procedure SetCPF(const Value: String);
protected
public
property ID :String read FID write FID;
property Nome :String read FNome write FNome;
property Sexo :String read FSexo write FSexo;
{Property CPF agora tem um mecanismo de validação para sua escrita}
property CPF :String read FCPF write SetCPF;
property RG :String read FRG write FRG;
property Telefone :String read FTelefone write FTelefone;
property Endereco :String read FEndereco write FEndereco;
property Bairro :String read FBairro write FBairro;
property Cidade :String read FCidade write FCidade;
property CEP :String read FCEP write FCEP;
published
end;
implementation
{ TCliente }
procedure TCliente.SetCPF(const Value: String);
begin
If Length(Value) = 14 Then
FCPF := Value
else
raise Exception.Create('CPF inválido, número de caracteres maior ou menor que 14');
end;
end.
Para usar sua classe e testar, faça o seguinte: crie um form e coloque um BitBtn.
Precisamos dar Uses em uCliente para poder acessar a Classe TCliente. Feito isso, no evento onClick do BitBtn, implemente o seguinte :
procedure TFrmCliente.BtnNovoClick(Sender: TObject);
Var
C: TCliente;
Begin
C := TCliente.Create;
C.Nome:= 'WESLEY YAMAZACK' ;
C.Bairro:= 'CENTRO' ;
C.CEP:= '216548-856 ' ;
C.ID:= '00005' ;
C.CPF := '123.456.789-100' ; // Deste jeito você vera o erro
C.CPF := '123.456.789-10' ; // Deste jeito irá funcionar
C.Sexo:= 'M' ;
C.Cidade:= 'RIO DE JANEIRO ' ;
C.Endereco:= 'RUA M, N 145, APTO 809' ;
C.Telefone:= '(21)3222-1111 ' ;
C.RG:= '12.313.214-1' ;
C.Free;
end;
