Programação
Orientada a Objeto - Parte III
Um exemplo prático em Delphi
Exemplo de POO na Linguagem Delphi (cont.)
Vá para a UClasses e abaixo da declaração da classe TPessoa crie duas classes descendentes da mesma como mostrado no código:
01 |
type |
02 |
TPessoa = class |
03 |
Nome: string; |
04 |
Fone: string; |
05 |
procedure Avaliar; |
06 |
constructor Create; |
07 |
destructor Destroy; |
08 |
end; |
09 |
|
10 |
TAluno = class(TPessoa) |
11 |
Turma: string; |
12 |
procedure Avaliar; |
13 |
constructor Create; |
14 |
destructor Destroy; |
15 |
end; |
16 |
|
17 |
TProf = class(TPessoa) |
18 |
Disciplina: string; |
19 |
procedure Avaliar; |
20 |
constructor Create; |
21 |
destructor Destroy; |
22 |
end; |
Nesse momento aplicamos o conceito de Herança, um vez que as classes TAluno e TProf são descendentes da classe TPessoa. Em seguida use o Ctrl+Shift+C nas classes e entre com o código em negrito:
01 |
implementation |
02 |
|
03 |
uses
Dialogs; |
04 |
|
05 |
{
TPessoa } |
06 |
|
07 |
procedure
TPessoa.Avaliar; |
08 |
begin |
09 |
ShowMessage('Avaliação sendo executada'); |
10 |
end; |
11 |
|
12 |
constructor
TPessoa.Create; |
13 |
begin |
14 |
Self.Nome := 'Novo Nome'; |
15 |
Self.Fone := 'Novo Fone'; |
16 |
end; |
17 |
|
18 |
destructor
TPessoa.Destroy; |
19 |
begin |
20 |
Self.Nome := ''; |
21 |
Self.Fone := ''; |
22 |
end; |
23 |
|
24 |
{
TAluno } |
25 |
|
26 |
procedure
TAluno.Avaliar; |
27 |
begin |
28 |
ShowMessage('Respondendo a prova'); |
29 |
end; |
30 |
|
31 |
constructor
TAluno.Create; |
32 |
begin |
33 |
Self.Nome := 'Novo Aluno'; |
34 |
Self.Turma := 'Nova Turma'; |
35 |
end; |
36 |
|
37 |
destructor
TAluno.Destroy; |
38 |
begin |
39 |
Self.Turma := ''; |
40 |
end; |
41 |
|
42 |
{
TProf } |
43 |
|
44 |
procedure
TProf.Avaliar; |
45 |
begin |
46 |
ShowMessage('Aplicando a prova'); |
47 |
end; |
48 |
|
49 |
constructor
TProf.Create; |
50 |
begin |
51 |
Self.Disciplina := 'Nova Disciplina'; |
52 |
end; |
53 |
|
54 |
destructor
TProf.Destroy; |
55 |
begin |
56 |
Self.Disciplina := ''; |
57 |
end; |
58 |
|
59 |
end. |
Novamente volte para o FPrincipal, mude o evento OnClick do TButton, compile e teste:
01 |
procedure TFPrincipal.Button1Click(Sender: TObject); |
02 |
var |
03 |
Pessoa: TPessoa; |
04 |
Aluno: TAluno; |
05 |
Prof: TProf; |
06 |
begin |
07 |
// Trabalhando com o objeto Pessoa |
08 |
Pessoa := TPessoa.Create; |
09 |
ShowMessage( 'Objeto Pessoa' +#13+ |
10 |
Pessoa.Nome +#13+ Pessoa.Fone ); |
11 |
Pessoa.Nome := 'Tadeu'; |
12 |
Pessoa.Fone := '1111-1111'; |
13 |
Pessoa.Avaliar; |
14 |
ShowMessage( 'Objeto Pessoa' +#13+ |
15 |
Pessoa.Nome +#13+ Pessoa.Fone ); |
16 |
Pessoa.Destroy; |
17 |
|
18 |
// Trabalhando com o objeto Aluno |
19 |
Aluno := TAluno.Create; |
20 |
ShowMessage( 'Objeto Aluno' +#13+ |
21 |
Aluno.Nome +#13+ Aluno.Fone +#13+
Aluno.Turma ); |
22 |
Aluno.Nome := 'José'; |
23 |
Aluno.Fone := '2222-2222'; |
24 |
Aluno.Turma := 'Comp02'; |
25 |
Aluno.Avaliar; |
26 |
ShowMessage( 'Objeto Aluno' +#13+ |
27 |
Aluno.Nome +#13+ Aluno.Fone +#13+
Aluno.Turma ); |
28 |
Aluno.Destroy; |
29 |
|
30 |
// Trabalhando com o objeto Prof |
31 |
Prof := TProf.Create; |
32 |
ShowMessage( 'Objeto Prof' +#13+ |
33 |
Prof.Nome +#13+ Prof.Fone +#13+
Prof.Disciplina ); |
34 |
Prof.Nome := 'Maria'; |
35 |
Prof.Fone := '3333-3333'; |
36 |
Prof.Disciplina := 'Linguagem II'; |
37 |
Prof.Avaliar; |
38 |
ShowMessage( 'Objeto Prof' +#13+ |
39 |
Prof.Nome +#13+ Prof.Fone +#13+
Prof.Disciplina ); |
40 |
Prof.Destroy; |
41 |
end; |
Note que mesmo sem termos declarado os campos Nome e Fone nas subclasses, elas herdaram esses campos da superclasse, dessa maneira a cada novo nível criada mais específico vai ficando a subclasse. O mesmo acontece com métodos que são declarados na superclasse e não o são na subclasse, mas no nosso exemplo redefinimos os métodos da superclasse, aplicando assim o conceito de Polimorfismo. A Linguagem Delphi garante o funcionamento correto do método desejado através do uso das palavras reservadas mostrada a tabela.
Palavra reservada |
Uso |
static |
Os métodos estáticos usam a implementação feita na subclasse que instância o objeto. Por default todo método é estático. |
virtual |
Embora os métodos virtuais usem a implementação feita na subclasse que instância o objeto, também podem ativar a implementação da superclasse. |
dynamic |
Semelhante ao anterior, o que os diferencia é que no caso anterior a velocidade de acesso é otimizada, enquanto no dynamic a otimização é feita em cima do código. Vale ressaltar que a diretiva virtual é a forma mais comum e eficiente de implementar o polimorfismo. |
override |
Essa diretiva garante que apenas uma implementação exista na classe descendente, ocultando as implementações das classes ancestrais. A assinatura do método deve ser igual em todas as classes descendentes e ancestrais, isso quer dizer que os métodos devem ter o mesmo nome e os seus parâmetros devem ter o mesmo número, tipo e ordem. Essa diretiva só pode ser usada com os métodos virtuais e dinâmicos. |
overload |
Essa diretiva permite que os métodos tenham assinaturas diferentes e não oculta as implementações das classes ancestrais, podendo ser usada com qualquer método – estático, virtual ou dinâmico. |
reintroduce |
Assim como a anterior permite que os métodos tenham assinaturas diferentes, mas nesse caso os métodos ancestrais são ocultados. Essa diretiva só pode ser usada com os métodos virtuais. |
abstract |
Essa diretiva é usada para determinar que o método não será implementado na classe onde foi declarada. Sua implementação deverá ser feita nas classes descendentes. Quando definimos um método como abstrato devemos ter em mente que a classe passa também a ser abstrata, não pode ser instanciada. Essa diretiva só pode ser usada em métodos virtuais e dinâmicos. |
final |
O uso dessa diretiva impede que classes descendentes redefinam métodos ancestrais. |
inherited |
Essa diretiva é usada para fazer uma chamada ao método ancestral e reaproveitar sua funcionalidade. |
Tabela 1 – Palavras reservadas para uso com métodos ancestrais e descendentes.
Este artigo foi cedido por http://www.cassic.com.br/ |