Programação Orientada a Objeto - Parte III

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
 (0)  (0)

Durante estes artigo será mostrado como aplicar na prática os quatro conceitos básicos da orientação a objeto (Abstração, Encapsulamento, Herança, Polimorfismo)

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/


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