Você está na página 1de 13

Nesse artigo veremos alguns conceitos bsicos

necessrios para o estudo da orientao a objetos.


Capitulo 1 Teoria Bsica de Orientao a Objetos Talvez uma
das coisas que mais causem medo e um enorme friozinho na
barriga de quem est comeando a programar em Delphi seja
exatamente a orientao a objetos (POO). No quero aqui
esgotar o tema, mas sim dar uma base para que voc possa se
aprofundar nesta tcnica e tirar o melhor proveito possvel.

Porm antes de iniciar este estudo necessrio que alguns
conceitos estejam bem claros, e que voc entenda e consiga
identificar facilmente cada um deles. So eles:

Classe: De uma maneira simples de se explicar, classe um
modelo, com referncia a propriedades que sero usadas
posteriormente. Por exemplo:
Vamos imaginar uma classe chamada TPessoa. Nesta classe
esto definidas as propriedades bsicas que todos os objetos
de TPessoa tero, como: Endereo, telefone, e-mail...

Herana: a capacidade de uma classe herdar propriedades
de outras classes. Imaginemos agora que vamos criar duas
novas classes que sero descendentes da classe TPessoa,
sendo assim herdaro todas as suas propriedades e ainda
sero acrescentadas novas propriedades que iro
personalizar estas novas classes.
Uma chamada TPessoaFis, que alm das propriedades da
classe TPessoa tero propriedades novas como:
NomeCompleto, CPF, RG, DataNascimento, Profissao.
E uma segunda classe chamada TPessoaJur que tambm
herdar as propriedades da classe TPessoa e ter como novas
propriedades: RazaoSocial, CNPJ, IE (Inscrio Estadual) e IM
(Inscrio Municipal), RamoAtividade.

Instncia: Instncia um elemento da classe. Vamos explicar
mais detalhadamente este conceito mais adiante, porm um
exemplo bsico pode ajud-lo a entender melhor o que uma
instncia.
TForm uma classe, com todas as propriedades genricas de
um formulrio de onde herdaro todos os formulrios que
compem um aplicativo.
TForm1 uma instncia da classe TForm com todas as
alteraes que voc fez para adequ-lo ao seu projeto.

Mtodo: So as aes que um objeto pode executar.

Encapsulamento: No estudo de POO o encapsulamento refere-
se a capacidade de uma classe de agrupar mtodos e
propriedades referentes a ela. Podemos ento comparar uma
classe a uma cpsula, onde por dentro ela tem tudo que
necessrio para funcionar perfeitamente, porm exibe apenas
o que precisa ser exibido.

Propriedades: So os atributos pertinentes a uma instncia.
Por exemplo, TForm1 possui uma propriedade chamada
Color onde definimos a cor especifica para este formulrio.

Construtor: o mtodo que vai instanciar uma classe, vai
atribuir suas propriedades e executar seus mtodos iniciais.

Destrutor: o mtodo que vai liberar da memria a instncia e
os recursos do sistema associados a ela.

Polimorfismo: a capacidade que um objeto tem de assumir
vrias formas. Veremos mais detalhadamente este conceito
nos prximos captulos.



Aqui tentei explicar de forma simples alguns conceitos bsicos
necessrios para o estudo da orientao a objetos. Como o
texto ficou um pouco extenso, separei em tpicos onde estarei
disponibilizando periodicamente. Espero que gostem.

Polimorfismo
Acredito que uma boa compreenso deste item seja
de grande importncia para os estudos da POO.
Ento resolvi fazer um artigo apenas sobre este
Acredito que uma boa compreenso deste item seja de grande importncia
para os estudos da POO. Pensando nisso, comecei a pesquisar na internet
uma forma simples de passar este conceito. Acabei encontrando um
pequeno programa que desenha em um componente TImage trs figuras
diferentes, atravs de uma classe pr-definida. Fiz algumas alteraes no
cdigo fonte deste programa para que a didtica e o entendimento fossem
facilitados. Bom, iremos criar neste exemplo uma classe chamada
TClassFigura, e dela criaremos outras 2 classes descendentes. Cada uma
destas classes ser responsvel pela criao de uma figura diferente.
Abra o seu Delphi, e crie uma nova Unit (File -> New -> Unit). Est unit
ser criada com o nome Unit1.

Verifique agora como ficar a nossa unit aps a criao da primeira classe.

unit Unit1;

interface

uses
extCtrls, graphics, classes;

type
TClassFigura = class
private
MinhaImagem: TImage;
public
property Imagem: TImage read MinhaImagem write MinhaImagem;
procedure Criar; virtual;
end;

implementation

end.


Informaes importantes:

TClassFigura = class
Sempre que declaramos uma classe sem especificar de quem ela
descendente, subentende-se que ela possui como classe-pai TObject, que
a classe-pai de toda e qualquer classe criada. Sua declarao opcional,
sendo assim poderamos declarar essa classe tambm como: TClassFigura
= class(TObject) que estaria correto da mesma forma, porm como vamos
a cima, isso no necessrio.

A frente da procedure Criar temos a palavra virtual, mas o que ela
significa?

Sempre que utilizamos a clausula virtual estamos sinalizando que nas
classe derivadas este mtodo poder ser reescrito. Para isso basta declarar
no mtodo da classe filha a clausula override.
Sempre que utilizamos a clausula override estamos reescrevendo um
mtodo da classe pai.


Bom, com esses conceitos descritos vamos ento implementar o cdigo da
classe TClassFigura. A implementao ficar da seguinte forma:

implementation

procedure TClassFigura.Criar;
begin
MinhaImagem.Canvas.Brush.Color := clYellow;
MinhaImagem.Canvas.Brush.Style := bsSolid;
MinhaImagem.Canvas.Pen.Color := clRed;
MinhaImagem.Canvas.Pen.Width := 3;
MinhaImagem.Canvas.Polygon([Point(10, MinhaImagem.Height -10),
Point(trunc(MinhaImagem.Width / 2.0), 0 + 10),Point(MinhaImagem.Width
- 10, MinhaImagem.Height -10)]);
MinhaImagem.Canvas.FloodFill(Trunc(MinhaImagem.Width / 2.0),
Trunc(MinhaImagem.Height / 2.0), clRed, fsBorder);
end;

Quando a classe pai (TClassFigura) for acionada, ela ir desenhar um
tringulo como figura padro.

Volte no inicio da Unit, onde declaramos a nossa classe pai, e vamos agora
criar duas novas classes que sero descendentes de TClassFigura. O estopo
da nossa Unit ficar assim:

unit Unit1;

interface

uses
extCtrls, graphics, classes;

type
TClassFigura = class
private
MinhaImagem: TImage;
public
property Imagem: TImage read MinhaImagem write MinhaImagem;
procedure Desenhar; virtual;
end;

TClassQuadrado = class(TClassFigura)
public
procedure Criar; override;
end;

TClassCirculo = class(TClassFigura)
public
procedure Criar; override;
end;

implementation

Lembra quando eu expliquei a diferena entre as clausulas virtual e
override? Agora acho que o conceito comear a fazer mais sentido...
Na classe pai quando acionada, desenhamos na tela um tringulo. Nas
classes filhas TClassCirculo e TClassQuadrado a procedure criar ser
sobrescrita e ir desenhar os desenhos que iremos definir quando
implementarmos a procedure criar das mesmas.

Vamos criar as classes filhas...

unit Unit1;

interface

uses
extCtrls, graphics, classes;

type
TClassFigura = class
private
MinhaImagem: TImage;
public
property Imagem: TImage read MinhaImagem write MinhaImagem;
procedure Desenhar; virtual;
end;

TClassQuadrado = class(TClassFigura)
public
procedure Criar; override;
end;

TClassCirculo = class(TClassFigura)
public
procedure Criar; override;
end;

Com a classe TClassCirculo ser desenhado na tela um Circulo e com a
classe TClassQuadrado ser desenhado um quadrado na tela. Vamos
implementar agora o metodo criar das classes filhas. Nossa Unit ento
ficaro do seguinte modo.

unit Unit1;

interface

uses
extCtrls, graphics, classes;

type
TClassFigura = class
private
MinhaImagem: TImage;
public
property Imagem: TImage read MinhaImagem write MinhaImagem;
procedure Desenhar; virtual;
end;

TClassQuadrado = class(TClassFigura)
public
procedure Criar; override;
end;

TClassCirculo = class(TClassFigura)
public
procedure Criar; override;
end;


procedure TClassFigura.Criar;
begin
MinhaImagem.Canvas.Brush.Color := clYellow;
MinhaImagem.Canvas.Brush.Style := bsSolid;
MinhaImagem.Canvas.Pen.Color := clRed;
MinhaImagem.Canvas.Pen.Width := 3;
MinhaImagem.Canvas.Polygon([Point(10, MinhaImagem.Height -10),
Point(trunc(MinhaImagem.Width / 2.0), 0 + 10),Point(MinhaImagem.Width
- 10, MinhaImagem.Height -10)]);
MinhaImagem.Canvas.FloodFill(Trunc(MinhaImagem.Width / 2.0),
Trunc(MinhaImagem.Height / 2.0), clRed, fsBorder);
end;

procedure TClassQuadrado.Criar;
begin
MinhaImagem.Canvas.Brush.Color :=clGreen;
MinhaImagem.Canvas.Brush.Style := bsSolid;
MinhaImagem.Canvas.Pen.Color := clRed;
MinhaImagem.Canvas.Pen.Width := 3;
MinhaImagem.Canvas.Rectangle(10, 10, MinhaImagem.Width - 10,
MinhaImagem.Height - 10);
end;

procedure TClassCirculo.Criar;
begin
MinhaImagem.Canvas.Brush.Color :=clBlue;
MinhaImagem.Canvas.Brush.Style := bsSolid;
MinhaImagem.Canvas.Pen.Color := clRed;
MinhaImagem.Canvas.Pen.Width := 3;
MinhaImagem.Canvas.Ellipse(10,10, MinhaImagem.Width - 10,
MinhaImagem.Height - 10);
end;

end.

Eu criei uma pasta chamada Classes no diretrio: C:\Arquivos de
programas\Borland\Delphi7 dessa forma eu centralizo em um nico local
todas as units que eu codifiquei. Essa uma dica para que voc no se
perca e saiba exatamente onde est aquela classe que voc fez e precisa
utilizar agora...

Nesta pasta salve sua unit com o nome UFiguras.

(Voc pode salvar sua unit no diretrio que preferir, est foi apenas uma
dica).

No Delphi clique em: Tools -> Enviroment Options -> aba Library.
Em Library Path clique nas reticncias ao lado da caixa de texto e localize o
diretrio onde voc salvou a unit.

Pronto, a unit com as classes est pronta para ser usada em qualquer um
dos seus projetos.
Fcil, n?

Vamos agora criar o aplicativo que manipula as classes criadas
anteriormente.
Crie um novo aplicarivo no Delphi (File -> New -> Application).

No Form1 da sua aplicao. Coloque dois componentes. Um TImage
(encontrado na paleta Additional) e um TButton (localizado na paleta
Standard).


Altere as propriedades dos componentes conforme descrito abaixo:
Form1:
Caption: Polimorfismo na Prtica
Name: FrmPolimorfismo
Height: 461
Widht: 580

TImage:
Height: 409
Left: 8
Top: 8
Widht: 473
Name: imgFigura

TButton:
Caption: Desenhar
Top: 112
Left: 488
Heght: 25
Widht: 75
Name: btnDesenhar

Na seo uses declare as units UFiguras e Math, ficar assim:

uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, Buttons, ExtCtrls, Unit2, Math;

Agora declare uma propriedade privada chamada Desenho. A declarao
ficar assim:

type
TFrmPolimorfismo = class(TForm)
ImgFigura: TImage;
btnDesenhar: TBitBtn;
procedure btnDesenharClick(Sender: TObject);
private
{ Private declarations }
Desenho: TClassFigura;
public
{ Public declarations }
end;

Agora d um duplo clique no boto e inclua o seguinte cdigo:

procedure TFrmPolimorfismo.btnDesenharClick(Sender: TObject);
var j: Integer;
begin
J := RandomRange(1,4);
Randomize;
if j = 1 then
begin
Desenho := TClassQuadrado.Create;
Desenho.Imagem := imgFigura;
Desenho.Criar;
Desenho.Free;
end else
if j = 2 then
begin
Desenho := TClassCirculo.Create;
Desenho.Imagem := imgFigura;
Desenho.Criar;
Desenho.Free;
end else
if j = 3 then
begin
Desenho := TClassFigura.Create;
Desenho.Imagem := imgFigura;
Desenho.Criar;
Desenho.Free;
end;
end;

Agora execute o programa e clique diversas vezes no boto Desenhar e veja
como o programa se comporta.

Encapsulamento
Uma breve explicao sobre Encapsulamento.

Utilizando aquele mesmo exemplo das classes criadas para desenhar formas
geomtricas explicarei uma outra propriedade do POO, o encapsulamento.

Voc reparou que ao criarmos a classe TClassFigura declaramos duas
propriedades? (Imagem e MinhaImagem)
Vou explicar agora o porque disso.

Sempre que criamos uma nova classe devemos nos preocupar em no
deixarmos expostos os atributos de um objeto, no deixando que eles
sejam acessados diretamente. Assim, ficaro disponveis apenas mtodos
que os manipularam.

Se voc olhar na unit TClassFigura ver que toda a codificao da classe
assim como das suas descendentes feita manipulando a propriedade
MinhaFigura, porm se voc chamar a classe em qualquer projeto no
conseguir visualizar ou manipular esta propriedade.
A manipulao feita atravs da propriedade Imagem que pblica, e est
por sua vez que passa as informaes necessrias a propriedade
MinhaImagem que quem realmente faz todo o trabalho pesado da nossa
classe.

Neste pequeno exemplo que criamos talvez isso no parea ser muito
necessrio, mas imagine um grande sistema com classes que controlam
incluso, alterao, consultas etc e que precisam de uma segurana e um
controle mais preciso? O encapsulamento faria todo esse trabalho de uma
forma bem simples ;)