Programação Orientada a Objetos

Transcrição

1 1 Programação Orientada a Objetos No Pascal da Borland a partir da versão 5.5 encontramos o tipo Object (palavra reservada) Encapsulamento Um tipo objeto é uma estrutura de dados que contém um número fixo de componentes. Os objetos encapsulam dados e rotinas. Na declaração do tipo object os dados são declarados com seus tipos (como em um record) e as rotinas apenas com seus cabeçalhos. objeto procedimentos Ex.: dados T1=object Campo1: ; Campo2: ; Procedure Rot1(parâmetros); Function Rot2: ; Constructor Inicia; Destructor Termina; As rotinas, também chamadas de métodos, são declaradas como: procedure, function, constructor ou destructor. As sintaxes das declarações dos dados e dos métodos são: Campo NomeCampo(s): tipo; Método procedure NomeMétodo(<parâmetro(s)>: tipo); function NomeMétodo(<parâmetro(s)>: tipo): tipo; constructor NomeMétodo(<parâmetro(s)>: tipo); destructor NomeMétodo(<parâmetro(s)>: tipo); Herança Um tipo object pode herdar componentes de outro tipo object.

2 2 Classe2 Classe1 Herança da Classe1 Ex.: T2=object(T1) Campo3: ; procedure Rot3; O tipo T2, além do Campo3 e da procedure Rot3, tem também os Campo1; Campo2, Rot1, Rot2, Inicia e Termina. Métodos Um método é um procedimento ou função declarada dentro de um tipo object. Os métodos são elementos utilizados para manipular os dados encapsulados dentro do tipo object. A declaração dentro de um tipo object consiste apenas do cabeçalho (como no forward). O corpo do método é definido fora da declaração do tipo object. Ex.: Procedure T1.Rot1(parâmetros);... Observe que o tipo object T1 aparece no instante da declaração do corpo da rotina. Um método pode ser estático, virtual ou dinâmico. Instanciação Para que os tipos object possam ser utilizados devemos declarar iáveis desses tipos, Esse tipo de declaração é denominado instanciação: Classe1 Objeto1 Objeto2 Objeto3 Instâncias da Classe1 Instanciação

3 3 Ex.: O1: T1; O2: T2; A iável O1 tem: dois campos (Campo1 e Campo2) e quatro métodos (Rot1, Rot2, Inicia, Termina). A iável O2 tem três campos (Campo1, Campo2 e Campo3) e cinco métodos (Rot1, Rot2, Inicia, Termina e Rot3). De outra forma poderíamos também utilizar instâncias alocadas dinamicamente. Esta forma é a mais comum. P3=^T3; T3=object(T2) Campo4: ; procedure Rot4;... O3: P3;... new(o3, Inicia); O3^.Rot2;... Termos utilizados em POO Nos exemplos: T1 e T2 são classes (em Pascal: objetos) O1 e O2 são objetos ou instâncias de T1 e T2 (em Pascal: iáveis) Campo1, Campo2 e Campo3 são dados-membro (em Pascal: campos) ou propriedades Rot1, Rot2, Rot3, Inicia e Termina são funções membro (em Pascal: métodos) Programa exemplo Programa exemplo utilizando programação orientada a objetos: TTipoDado=Real; TIndice=1..6; TVet=array [TIndice] of TTipoDado; TVetUni=object V: TVet; procedure Atrib(i: TIndice; Val: TTipoDado); function Consu(i: TIndice): TTipoDado; procedure TVetUni.Atrib(i: TIndice; Val: TTipoDado); if (i<1) or (i>6) then writeln('índice Inválido') else V[i]:=Val;

4 4 function TVetUni.Consu(i: TIndice): TTipoDado; if (i<1) or (i>6) then writeln('índice Inválido') else Consu:=V[i]; V1, V2: TVetUni; X: TTipoDado; V1.Atrib(1, 7.2); (* atribuiçao *) V2.Atrib(2, 3.5); with V1 do Atrib(3, 0.4); Atrib(4,-1.0); Atrib(5, 2.3); V2.Atrib(6,-9.2); X:=V1.Consu(1)+V2.Consu(2); (* consulta e operaçoes *) Duas palavras reservadas são exclusivas no tipo object: private e public. Essas palavras criam seções dentro de um tipo object restringindo ou ampliando o escopo dos campos. Os escopos dos componentes declarados na seção private são restritos ao módulo (programa ou unit) que contém o objeto onde o tipo object está declarado. Dentro do módulo, um componente private atua como um componente public; Fora do módulo, um componente private não é conhecido nem acessível. Teoricamente um objeto seguro deveria ter todos os seus campos private. Isso impediria que acessos "mal comportados" alterassem o funcionamento esperado do objeto. Todas as alterações aos campos seriam feitas através de chamadas aos métodos públicos do objeto. O programa abaixo pode utilizar a unidade ADAI_1A.TPU ou ADAI_1B.TPU (apresentadas abaixo). uses ADAI_1?; VE, X: TVetUni; i: TIndice; VE.Inicia; for i:=1 to 3 do VE.Atrib(i, i-2); for i:=1 to 3 do VE.Atrib(i, i-1); for i:=1 to 3 do writeln(ve.consu(i)); Observe que a classe TVetUni nas duas unidades (ADAI_1A.TPU e ADAI_1B.TPU) tem a mesma interface pública. Observe ainda as três formas de implementação de vetor esparso com OOP e suas diferenças.

5 5 unit ADAI_1A; interface const MaxElem=1000; TTipoDado=Real; TIndice=1..MaxElem; TVet=array [TIndice] of TTipoDado; TVetUni=object private V: TVet; public procedure Inicia; procedure Atrib(i: TIndice; Val: TTipoDado); function Consu(i: TIndice): TTipoDado; implementation procedure TVetUni.Inicia; i: TIndice; for i:=1 to MaxElem do V[i]:=0; procedure TVetUni.Atrib(i: TIndice; Val: TTipoDado); if (i<1) or (i>6) then writeln('índice Inválido') else V[i]:=Val; function TVetUni.Consu(i: TIndice): TTipoDado; if (i<1) or (i>6) then writeln('índice Inválido') else Consu:=V[i]; unit ADAI_1B; interface const MaxElem=1000; MaxElemDifer0=50; TTipoDado=Real; TIndice=1..MaxElem; TVetUni=object private M: Array [1..MaxElemDifer0] of record Valor: TTipoDado; Ind: integer; function Encontra(Ind: integer): integer; public procedure Inicia; procedure Atrib(I: TIndice; Val: TTipoDado); function Consu(I: TIndice): TTipoDado;

6 6 implementation procedure TVetUni.Inicia; i: integer; for i:=1 to MaxElemDifer0 do M[i].Ind:=-1; function TVetUni.Encontra(Ind: integer): integer; i: integer; i:=1; while (i<=maxelemdifer0) and (M[i].Ind<>Ind) do Inc(i); if i<=maxelemdifer0 then Encontra:=i else Encontra:=-1; (* indicador de nao encontrado *) function TVetUni.Consu(I: TIndice): TTipoDado; Ind: integer; Ind:=Encontra(I); if Ind<>-1 then Consu:=M[Ind].Valor else Consu:=0; procedure TVetUni.Atrib(I: TIndice; Val: TTipoDado); Ind: integer; Ind:=Encontra(I); if Val=0 then if Ind<>-1 then M[Ind].Ind:=-1 (* retira elemento da tabela *) end else if Ind<>-1 then M[Ind].Valor:=Val (* já existe o índice *) else Ind:=Encontra(-1); (* encontra índice vazio *) if Ind=-1 then writeln('erro, nao cabe mais') else M[Ind].Ind:=i; M[Ind].Valor:=Val end end Mensagens Conceitualmente, na OOP, os objetos, em um programa, interagem através da troca de mensagens. No mínimo, enviar uma mensagem envolve especificar o nome de um objeto e o nome da mensagem a ser enviada. Constantemente haverá também argumentos que deverão ser especificados. Podemos imaginar, em um certo sentido, que cada objeto se comporta como um pequeno programa especializado, que se comunica através das mensagens com outros programas especializados.

7 7 As trocas de mensagens em Pascal são simples chamadas às subrotinas (métodos) dos objetos. Assim se na linguagem da OOP dizemos: o objeto O1 envia uma mensagem M ao objeto O2, em Pascal a mensagem M para O2 seria: O2.M, onde O2 é uma instância e M é uma rotina declarada na classe de O2. Métodos Virtuais Um método declarado como virtual pode ser substituído nas suas classes descendentes. Essas rotinas usam uma tabela adicional para identificar em qual classe está o método a ser chamado. Assim, a ligação desses métodos não ocorre no instante da ligação (link), ela ocorre no instante em que o método será executado. Esse tipo de ligação recebe o nome de vinculação tardia de métodos no momento de execução ( runtime late binding of methods ). A=object procedure M1; procedure M2; virtual; B=object(A) procedure M2; virtual; procedure A.M1; writeln('a.m1'); M2; procedure A.M2; writeln('a.m2'); procedure B.M2; writeln('b.m2'); Classe A ObjA: A; ObjB: B; ObjA.M1; ObjB.M1; Método M1 M1 chama M2 Método M2 Classe B Método M2 A figura mostra a classe A com duas funções, M1 e M2, tal que M1 chama M2; e a classe B que é subclasse de A. Considerando a criação de dois objetos a partir de A e B, teremos respectivamente ObjA e ObjB. Quando uma mensagem M1 é enviada para ObjA as funções M1 e M2 de A serão executadas. O que acontecerá se a mensagem M1 for para ObjB? 1 O sistema em execução pega a mensagem ObjB.M1 e tenta encontrar o método M1 na classe B. 2 A ação 1 fracassa e o sistema procura nos métodos das classes mães (classe A). A busca tem sucesso e o código do método A.M1 é usado. 3 Como o método A.M1 chama o método M2, o sistema em execução precisa resolver a chamada: 1 a Se M2 NÃO for virtual: A.M2 será imediatamente executado (a vinculação foi feita na ligação e, portanto, é estática); 2 a Se M2 for virtual: o sistema primeiro volta aos métodos da classe B (a classe cuja instância recebeu a mensagem original) e tenta localizar um método M2. A busca tem sucesso e o sistema emprega o código de B.M2 para resolver a chamada de ObjA.M1 (a vinculação é feita no instante da execução). O Borland Pascal utiliza uma tabela (tabela de métodos virtuais) para resolver a vinculação tardia. Essa tabela é alocada e iniciada por um método especial chamado construtor e liberada por outro método especial chamado destrutor. Assim, sempre que forem utilizados métodos virtuais é

8 necessária a iniciação da tabela de métodos virtuais, no momento da instanciação, que é executada por um dos construtores da classe. A forma correta de escrever a classe apresentada anteriormente é: 8 A=object constructor C; procedure M1; procedure M2; virtual; destructor D; B=object(A) procedure M2; virtual constructor A.C; destructor A.D; procedure A.M1; writeln('a.m1'); M2; procedure A.M2; writeln('a.m2'); procedure B.M2; writeln('b.m2'); ObjA: A; ObjB: B; ObjA.C; ObjB.C; ObjA.M1; ObjB.M1; ObjA.D; ObjB.D; Note que neste exemplo não existe instrução executável no corpo do método construtor nem no destrutor, eles são declarados e chamados apenas para criar e destruir a tabela de métodos virtuais. Exemplo: TPessoa=object Nome, Endereco: string[30]; RG: longint; procedure LeDados; procedure Mostra; procedure Titulo(funcao: string); procedure TPessoa.Titulo(funcao: string); writeln('-- ', funcao, ' Pessoa: --'); writeln; procedure TPessoa.LeDados; Titulo('Le Dados'); write('nome: '); readln(nome); write('endereco: '); readln(endereco); write('r.g.: '); readln(rg); No vídeo teremos: -- Le Dados Pessoa: -- Nome: João Endereco: XV de novembro S/N R.G.: Mostra Pessoa: -- Nome: João Endereco: XV de novembro S/N R.G.:

9 9 procedure TPessoa.Mostra; Titulo('Mostra'); writeln('nome: ', nome); writeln('endereco: ', endereco); writeln('r.g.: ', RG); Pessoa: TPessoa; Pessoa.LeDados; Pessoa.Mostra; O programa abaixo coloca uma nova classe descendente de TPessoa. Observe que no instante da impressão em vídeo o título é mostrado como: -- "funcao" Pessoa -- ou seja, o método TAluno.Titulo NÃO foi usado. TPessoa=object Nome, Endereco: string[30]; RG: longint; procedure LeDados; procedure Mostra; procedure Titulo(funcao: string); procedure TPessoa.Titulo(funcao: string); writeln('-- ', funcao, ' Pessoa: --'); writeln; procedure TPessoa.LeDados; Titulo('Le Dados'); write('nome: '); readln(nome); write('endereco: '); readln(endereco); write('r.g.: '); readln(rg); procedure TPessoa.Mostra; Titulo('Mostra'); writeln('nome: ', Nome); writeln('endereco: ', Endereco); writeln('r.g.: ', RG); TAluno=object(TPessoa) Numero: longint; procedure LeDados; procedure Mostra; procedure Titulo(funcao: string); No vídeo teremos: -- Le Dados Pessoa: -- Nome: João Endereco: XV de novembro S/N R.G.: Numero: Mostra Pessoa: -- Nome: João Endereco: XV de novembro S/N R.G.: Numero: 111

10 10 procedure TAluno.Titulo(funcao: string); writeln('-- ', funcao, ' Aluno: --'); writeln; procedure TAluno.LeDados; TPessoa.LeDados; write('numero: '); readln(numero); procedure TAluno.Mostra; TPessoa.Mostra; writeln('numero: ', Numero); Aluno: TAluno; Aluno.LeDados; Aluno.Mostra; O programa abaixo corrige o anterior utilizando um método virtual Observe que foram utilizados dois métodos especiais o: constructor Inicia; e destructor Termina indispensáveis em objetos que utilizam métodos virtuais. TPessoa=object Nome, Endereco: string[30]; RG: longint; constructor Inicia; procedure LeDados; procedure Mostra; procedure Titulo(funcao: string); virtual; destructor Termina; constructor TPessoa.Inicia; procedure TPessoa.Titulo(funcao: string); writeln('-- ', funcao, ' Pessoa: --'); writeln; procedure TPessoa.LeDados; Titulo('Le Dados'); write('nome: '); readln(nome); write('endereco: '); readln(endereco); write('r.g.: '); readln(rg);

11 11 procedure TPessoa.Mostra; Titulo('Mostra'); writeln('nome: ', Nome); writeln('endereco: ', Endereco); writeln('r.g.: ', RG); destructor TPessoa.Termina; TAluno=object(TPessoa) Numero: longint; procedure LeDados; procedure Mostra; procedure Titulo(funcao: string); virtual; procedure TAluno.Titulo(funcao: string); writeln('-- ', funcao, ' Aluno: --'); writeln; procedure TAluno.LeDados; TPessoa.LeDados; write('numero: '); readln(numero); procedure TAluno.Mostra; TPessoa.Mostra; writeln('numero: ', Numero); Aluno: TAluno; No vídeo teremos: -- Le Dados Aluno: -- Nome: João Endereco: XV de novembro S/N R.G.: Numero: Mostra Aluno: -- Nome: João Endereco: XV de novembro S/N R.G.: Numero: 111 Aluno.Inicia; Aluno.LeDados; Aluno.Mostra; Aluno.Termina; Note no programa acima que as rotinas TAluno.Mostra e TAluno.LeDados chamam as mesmas rotinas declaradas na classe mãe, que agora estão sendo substituídas. Esta facilidade é muito útil em classes descendentes de classes complexas, quando toda a complexidade não precisa ser repetida.

12 12 Criando Instancias em Borland Pascal Utilizaremos o exemplo anterior: PPessoa=^TPessoa; TPessoa=object Nome, Endereco: string[30]; RG: longint; constructor Inicia; procedure LeDados; procedure Mostra; procedure Titulo(funcao: string); virtual; destructor Termina;... PAluno=^TAluno; TAluno=object(TPessoa) Numero: longint; procedure LeDados; procedure Mostra; procedure Titulo(funcao: string); virtual;... A instanciação utiliza até agora foi: Aluno: TAluno; Aluno.Inicia; Aluno.LeDados; Aluno.Mostra; Aluno.Termina; Existe ainda uma forma mais utilizada que cria uma instancia a partir de memória alocada dinamicamente. Três formas podem ser utilizadas: Forma 1: Aluno: PAluno; New(Aluno); Aluno^.Inicia; Aluno^.LeDados; Aluno^.Mostra; Aluno^.Termina; Dispose(Aluno);

13 13 Forma 2: Aluno: PAluno; New(Aluno, Inicia); Aluno^.LeDados; Aluno^.Mostra; Dispose(Aluno, Termina); Forma 3: Aluno: PAluno; Aluno:=New(PAluno, Inicia); Aluno^.LeDados; Aluno^.Mostra; Dispose(Aluno, Termina); Para exemplificar a utilização da programação orientada a objetos usaremos o Turbo Vision que é fornecido pela Borland junto com o Borland Pascal 7.0. Este pacote facilita a criação de interfaces com janelas em ambiente DOS. program Minimal; uses App; MyApp: TApplication; MyApp.Init; MyApp.Run; MyApp.Done; program Tutor02b; Alt-X Exit uses App, Objects, Menus, Drivers, Views; TTutorApp = object(tapplication) procedure InitMenuBar; virtual; procedure InitStatusLine; virtual; Arquivo Abre... F3 Salva F2 Sair Alt-S procedure TTutorApp.InitMenuBar; R: TRect; GetExtent(R); R.B.Y := R.A.Y + 1; MenuBar := New(PMenuBar, Init(R, NewMenu( NewSubMenu('~A~rquivo', hcnocontext, NewMenu( NewItem('~A~bre...', 'F3', kbf3, cmopen, hcopen, NewItem('~S~alva', 'F2', kbf2, cmsave, hcsave, NewLine( NewItem('Sai~r~', 'Alt+S', kbalts, cmquit, hcexit, nil))))), nil))));

14 14 procedure TTutorApp.InitStatusLine; R: TRect; GetExtent(R); R.A.Y := R.B.Y - 1; Alt+F Sair New(StatusLine, Init(R, NewStatusDef(0, $EFFF, NewStatusKey('~Alt+F~ Sair', kbaltf, cmquit, nil), nil))); TutorApp: TTutorApp; TutorApp.Init; TutorApp.Run; TutorApp.Done; program InsWin; uses Objects, App, Drivers, Views, Menus; const cmnewwin = 2000; TInsApp = object(tapplication) WinCount: Integer; procedure HandleEvent( Event: TEvent); virtual; procedure InitMenuBar; virtual; procedure TInsApp.HandleEvent( Event: TEvent); R: TRect; inherited HandleEvent(Event); if Event.What = evcommand then if Event.Command = cmnewwin then Inc(WinCount); Desktop^.GetExtent(R); InsertWindow(New(PWindow, Init(R, 'Test window', WinCount))); procedure TInsApp.InitMenuBar; R: TRect; GetExtent(R); R.B.Y := R.A.Y + 1; MenuBar := New(PMenuBar, Init(R, NewMenu( NewItem('~A~dd window', 'F3', kbf3, cmnewwin, hcnocontext, nil)))); Add Window InsApp: TInsApp; InsApp.Init; InsApp.Run; InsApp.Done; Alt-X Exit

15 15 Além do Turbo Vision a Borland oferece também um pacote, chamado Object Windows, voltado a criação de interfaces no ambiente Windows. O exemplo abaixo cria uma janela vazia sem título. program Vazio; uses OWindows; MyApp: TApplication; MyApp.Init('Vazio'); MyApp.Run; MyApp.Done; O exemplo abaixo cria uma janela vazia com o título "XXXXX". program Step01a; uses OWindows; TMyApplication = object(tapplication) procedure InitMainWindow; virtual; procedure TMyApplication.InitMainWindow; MainWindow := New(PWindow, Init(nil, 'XXXXX')); MyApp: TMyApplication; MyApp.Init('Steps'); MyApp.Run; MyApp.Done; O exemplo abaixo cria uma janela com o título "YYYYY". Esta janela é capaz de atender ao clicar do botão esquerdo do mouse. Sempre que o botão esquerdo for pressionado um dialogo de mensagem será aberto com o texto: "You have pressed the left mouse button" program Step01b; uses WinTypes, WinProcs, OWindows; PStepWindow = ^TStepWIndow; TStepWindow = object(twindow) procedure WMLButtonDown( Msg: TMessage); virtual wm_first + wm_lbuttondown; TMyApplication = object(tapplication) procedure InitMainWindow; virtual; procedure TStepWindow.WMLButtonDown( Msg: TMessage); MessageBox(HWindow, 'You have pressed the left mouse button', 'Message Dispatched', mb_ok);

16 16 procedure TMyApplication.InitMainWindow; MainWindow := New(PStepWindow, Init(nil, 'YYYYY')); MyApp: TMyApplication; MyApp.Init('Steps'); MyApp.Run; MyApp.Done;