Apesar do povo no twitter querer me massacrar quando digo que o Delphi é uma linguagem (muito boa por sinal), há muito que ele não trata mais de Pascal com uma IDE bonitinha. Mas como eu respondi lá, isso é uma questão comercial, que pouco me importa, afinal, não ganho ou perco um centavo com isso. Quanto a linguagem ser boa, não há dúvidas, com ela eu construi minha casa, estou pagando o carro, os meus treinamentos, a educação do meu filho…
Piadas à parte, vamos ao ponto, no último post que eu tratei sobre o assunto (Orientação à Objetos) a coisa ficou meio descontextualizada, principalmente por se tratar de uma palestra que fiz aqui na Produtec. Assim, vou tentar simplificar um pouco mais o conceito, sem necessariamente entrar na conversa com o banco.
Primeiro vamos imaginar um problema. Alguém lhe fez a solicitação:
Criar uma classe Lampada, que tenha como ser ligada, desligada e possa me responder seu atual estado (ON/OFF). Essa pessoa lhe solicitou também um formulário que interagisse com essa classe, acessando os seus métodos.
Então vejamos, temos uma classe mais ou menos como a desenhada abaixo:
Como vemos, teremos então a classe Lampada, que possuirá um atributo privado chamado acesa do tipo boleano e três métodos públicos bastante simples; ligarLampada() muda o atributo acesa para true, desligarLampada() seta o atributo para false e isLampadaLigada() que retorna o estado do atributo. Até aqui bem simples.
Para a implementação eu vou herdar de TControl, por enquanto isso será suficiente, afinal não quero ter que implementar as coisas mais básicas na mão, como a criação do componente e tal. Isso fica mais ou menos assim:
unit uLampada;
interface
uses Controls;
type
TLampada = class(TControl)
private
Facesa: Boolean;
procedure Setacesa(const Value: Boolean);
property acesa: Boolean read Facesa write Setacesa;
public
procedure LigarLampada;
procedure DesligarLampada;
function isLampadaLigada: Boolean;
end;
implementation
{ TLampada }
procedure TLampada.DesligarLampada;
begin
acesa := False;
end;
function TLampada.isLampadaLigada: Boolean;
begin
Result := acesa;
end;
procedure TLampada.LigarLampada;
begin
acesa := True;
end;
procedure TLampada.Setacesa(const Value: Boolean);
begin
Facesa := Value;
end;
end.
Percebam aqui algumas particularidades do Delphi. Pra começar, os métodos tem um “tipo”. Métodos que necessitam retornar valores são declarados como function e os que não precisam retornar valor, portanto são somente procedimentos, são assim chamados procedure. Ambos podem receber parâmetros, mas no nosso exemplo não tivemos necessidade. A única diferença é mesmo o retorno.
Para declarar a propriedade acesa, eu simplesmente digitei property acesa:boolean; e pressionei o atalho Ctrl+Shift+C. Isso nos leva a outro ponto legal de destacar que é o encapsulamento. Veja como ficou o código:
private
Facesa: Boolean;
procedure Setacesa(const Value: Boolean);
property acesa: Boolean read Facesa write Setacesa;
Assim, na prática, o valor será gravado em Facesa (o “F” é padrão do Delphi, não pergunte). Como se percebe ele completou a linha com as cláusulas read e write, determinado assim o Getter e o Setter da propriedade acesa. Portanto quando uma chamada um outro objeto acessar a propriedade acesa, a classe irá ler o valor da variável Facesa e na hora de atribuir o valor, o procedimento Setacesa(const Value: Boolean);.
A cláusula const antes do parâmetro indica que o mesmo não pode ser alterado no corpo do procedimento. Ele pode ser atribuído normalmente na chamada.
Com o procedimento SetAcesa podemos colocar quaisquer tratamentos que se fizerem necessários. Mas isso é assunto para outro post.
Para a aplicação rodar como pedido, devemos criar um formulário que interaja com um objeto da classe criada. Vou não criar muita firula aqui, serão apenas 3 botões, Ligar, Desligar e Status.
Aqui fica mais clara ainda a simplicidade desse sistema. Basta criar uma instância da classe TLampada e fazer com que os botões acessem os seus métodos. Veja como ficou simples.
unit uInterruptor;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, uLampada;
type
TfrmInterruptor = class(TForm)
btnLigar: TButton;
btnDesligar: TButton;
btnStatus: TButton;
procedure btnStatusClick(Sender: TObject);
procedure btnDesligarClick(Sender: TObject);
procedure btnLigarClick(Sender: TObject);
procedure FormCreate(Sender: TObject);
private
MinhaLampada: TLampada;
public
end;
var
frmInterruptor: TfrmInterruptor;
implementation
{$R *.dfm}
procedure TfrmInterruptor.btnDesligarClick(Sender: TObject);
begin
MinhaLampada.DesligarLampada;
end;
procedure TfrmInterruptor.btnLigarClick(Sender: TObject);
begin
MinhaLampada.LigarLampada;
end;
procedure TfrmInterruptor.btnStatusClick(Sender: TObject);
var
cMsg: String;
begin
cMsg := 'A lâmpada ';
if not MinhaLampada.isLampadaLigada then
cMsg := cMsg + 'não ';
cMsg := cMsg + 'está ligada.';
ShowMessage(cMsg);
end;
procedure TfrmInterruptor.FormCreate(Sender: TObject);
begin
MinhaLampada := TLampada.Create(Self);
end;
end.
A única dica é criar a MinhaLampada na criação do formulário. Não preciso me preocupar com dispor dela, pois ela foi criada “afiliada” ao form, portanto quando um for para o vinagre o outro vai junto.
Bom pessoal, agora que desaceleramos e começamos de maneira mais básica acho que consegui isolar um pouco mais os conceitos. Acredito que todos entendem que temos uma classe TLampada, com atributos privados, com métodos públicos que nos permitem controlar a lâmpada. Esclarecemos também que o que se manipula posteriormente é a instancia, o objeto MinhaLampada, não a classe. E podemos ter quantas instancias da Lampada criadas dentro da nossa aplicação.
No próximo post sobre o assunto vamos criar um serviço que controle a “energia” do exemplo. Até lá.
Comment