Guia Delphi

Class: Read e Write no Delphi

Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Para efetuar o download você precisa estar logado. Clique aqui para efetuar o login
Confirmar voto
0
 (11)  (0)

Veja neste artigo onde explico como usar, e pra que serve os métodos usados na criação de uma classe. De maneira bem simples entenderemos pra que serve, quando usar, e quando não usar.

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, para isso criarmos uma unit, e vamos salvar seu nome como uCliente.pas

unit uCliente;
  interface
  implementation
end.

Neste momento vamos criar a 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, iremos usar a combinação de teclas CTRL + SHIF + C, para implementar a classe.
Seu código agora irá modificar complementa, 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 2 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, porém 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 um exemplo 123.456.789-01.

Usando a função Length , encontrada na unit System, podemos ver o tamanho de uma string, veja como ficaria o código para saber 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 negocio 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á esta 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 negocio para suas propertys ok? Caso tenha você faz como o Delphi implementa, cria a procedure, associa ela ao Write da property e implementa ela com sua regra de negócio. Ficará então da seguinte forma com a única regra de negocio que criamos, a do tamanho do CPF

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;


Com isso fico por aqui, até um próximo artigo, um abraço

Wesley Y

 
Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Receba nossas novidades
Ficou com alguma dúvida?