Reflexão Módulo 8

Neste módulo começamos com um novo tipo de programação: programação orientada a objetos.
A longo deste módulo aprendi a identificar as diferenças entre linguagem estruturada e linguagem orientada por objetos; fiquei a conhecer as noções de objeto, classe, membro, atributo, método...; aprendi a compreender as caraterísticas da POO designadas por encapsulamento, herança e polimorfismo; fiquei a conhecer a diferença entre acesso público e privado aos membros de uma classe e aprendi a diferença entre POO  e programação dirigida por eventos.

Módulo 8 - Programação Orientada a Objetos

O que é a Programação Orientada a 

Objetos?

A programação Orientada a objetos (POO) é uma forma especial de programar, mais próximo de como expressaríamos as coisas na vida real do que outros tipos de programação.

Com a POO temos que aprender a pensar as coisas de uma maneira distinta, para escrever nossos programas.

A Programação Orientada a Objetos carateriza-se, fundamentalmente, pela criação de classes, que, depois, são usadas nos programas sob a forma de objetos.

Para além disso, a POO tem também as seguintes carateristicas principais:

Encapsulamento: as classes e os objetos são unidades de código que encobrem e protegem os seus membros em relação a acessos externos;

Herança: as classes podem ser criadas com base noutras classes, herdando os seus membros;

Polimorfismo: um determinado método de uma classe ou conjunto de classes pode ter várias versões ou formas para funcionar em diferentes contextos. 

Classes em POO

As classes são declarações de objetos, também se poderiam definir como abstrações de objetos. Isto quer dizer que a definição de um objeto é a classe. Quando programamos um objeto e definimos suas características e funcionalidades na verdade o que estamos a fazer é programar uma classe.

Atributos nas classes

Os campos de dados ou atributos são as características dos objetos. Quando definimos um atributo normalmente especificamos seu nome e o seu tipo. Podemos ter a ideia de que os atributos são algo assim como as variáveis onde armazenamos os dados relacionados com os objetos.

Métodos nas classes

São as funcionalidades associadas aos objetos. Quando estamos a programar  as classes elas chamam-se de métodos. Os métodos são como funções ou procedimentos que estão associadas a um objeto.

Objetos em POO

Os objetos são exemplares de uma classe qualquer. Quando criamos um exemplar temos que especificar a classe a partir da qual se criará.

Para proteger os dados existentes nos objetos  foram criados os seguintes modificadores de acesso que são utilizados durante a criação das classes:

Private (acesso privado): indica que o membro da classe (dado ou método) só pode ser acedido no interior do código da classe;

Public (acesso publico): indica que o membro da classe (dado ou método) pode ser acedido em qualquer parte do código de um programa que inclua aquela classe.

O que são procedimentos de evento?

É nestes procedimentos de evento que um programador, num ambiente dirigido por eventos, irá escrever grande parte do código das suas aplicações.

Exemplos de ficheiros:

Exemplo de um ficheiro do tipo definido pelo programador:


Program estacionamento;
type popo=record
marca:string;
matricula:string;
tempo:integer;
tipo:string;
end;
var fich: file of popo;
i,n,cont,maior,op:integer;
mat,matri:string;
        parque:popo;
procedure criar_ficheiro;
begin
assign(fich,'estacionar');
rewrite(fich);
end;
procedure dados;
begin
reset(fich);
writeln('Quantos ve¡culos?');
readln(n);
seek(fich, filesize(fich));
for i:=1 to n do
begin
writeln('Introduza a marca do ve¡culo');
Readln(parque.marca);
Writeln('Introduza a matr¡cula do ve¡culo');
readln(parque.matricula);
writeln('Tempo de estacionamento');
readln(parque.tempo);
writeln('Introduza o tipo de ve¡culo - ligeiro, pesado, moto');
readln(parque.tipo);
                        Writeln('*************************************');
                writeln('*************************************');
write(fich,parque);
end;
close(fich);
end;
procedure listar;
begin
reset(fich);
cont:=0;
        If filesize(fich)=0 then
        Write('NÆo h  registos no ficheiro')
        Else
        Begin
while not eof (fich) do
begin
read(fich,parque);
Writeln('Matricula: ',parque.matricula);
Writeln('Tempo de estacionamento: ', parque.tempo);
Writeln('Tipo de veiculo: ', parque.tipo);
writeln('****************************************');
                        writeln('****************************************');
cont:=cont+parque.tempo;
end;
writeln('Tempo m‚dio: ', cont/filesize(fich));
        seek(fich,0);
maior:=parque.tempo;
mat:=parque.matricula;
while not eof (fich) do
begin
if maior<parque.tempo then
begin
maior:=parque.tempo;
mat:=parque.matricula;
end;
end;
writeln('Autom¢vel com mais tempo:',mat,'Tempo= ',maior);
        end;
close(fich);
end;
procedure alterar;
begin
writeln('Introduza a matr¡cula a alterar dados');
read(matri);
reset(fich);
seek(fich,0);
while not eof (fich) do
begin
if parque.matricula=matri then
begin
Writeln('MARCA');
readln(parque.marca);
writeln('Matr¡cula');
readln(parque.matricula);
writeln('Tempo estacionado');
readln(parque.tempo);
write(fich,parque);
end
else
writeln('Matr¡cula nÆo encontrada');
end;
close(fich);
end;
procedure relatorio;
begin
reset(fich);

while not eof (fich) do
        begin
        read(fich, parque);
if parque.tipo='moto' then
             begin
Writeln('Matr¡cula: ', parque.matricula);
writeln('Tempo: ', parque.tempo);
writeln('Valor pago: ', (0.04*parque.tempo)*0.2);
writeln('*********************************************');
                              writeln('*********************************************');
             end;
if parque.tipo='ligeiro' then
             begin
       Writeln('Matrícula: ', parque.matricula);
writeln('Tempo: ', parque.tempo);
writeln('Valor pago: ', (0.08*parque.tempo)*0.2);
writeln('*********************************************');
                              writeln('*********************************************');
             end;
if parque.tipo='pesado' then
             begin
               Writeln('Matrícula: ', parque.matricula);
writeln('Tempo: ', parque.tempo);
writeln('Valor pago: ', (0.1*parque.tempo)*0.2);
writeln('*********************************************');
                              writeln('*********************************************');
             end;
end;
        close(fich);
end;
procedure apagar;
begin
rewrite(fich);
end;
 Begin
    repeat
writeln('Escolha uma das opções');
    Writeln('*1-Criar ficheiro');
    Writeln('*2-Introduzir registos');
    writeln('*3-Apresentar dados');
    writeln('*4-Alterar dados');
    writeln('*5-Relat¢rio de contas');
    writeln('*6-Limpar dados');
    writeln('*7-Sair');
    readln(op);
    case op of
    1:criar_ficheiro;
    2:dados;
    3:listar;
    4:alterar;
    5:relatorio;
    6:apagar;
    end;
until(op=7);
 End.

Exemplo de um ficheiro do tipo texto:


Program Ficheiro_texto_1;
var F1, F2: Text;
        linha, nome:string;

begin
        assign(F1,'TESTE1.txt');
        rewrite(F1);
        write(F1,'ISTO  UM TESTE COM');
        write(F1,'FICHEIRO DE TEXTO');
        write(F1,'ESCREVA MAIS...');
        CLOSE(F1);
        Reset(F1);
        While not Eof (f1) do
         begin
                readln (f1,linha);
                writeln(linha);
        end;
        close(f1);
        writeln('Escvreva um nome de pessoa');
        readln(nome);
        append(f1);
        write(f1,nome);
        close(f1);
        reset(f1);
        while not Eof(f1)do
        begin
        readln(f1,linha,nome);
        Writeln(nome);
        Writeln(linha);
        end;
        close(f1);
        assign (F2,'Teste2.txt');
        rewrite(f2);
        while not eof (f1)do
                begin
                        readln(F1,linha);
                        writeln(F2,linha);
                end;
         while not eof (f2)do
                begin
                        readln(F2,linha);
                        write(linha);
                end;

 end.

Ficheiros

O que são ficheiros?

Um Programa Pascal pode comunicar com um ou vários Ficheiros, tanto para a Leitura de Dados, como para a Escrita de Resultados.

Os Ficheiros são exteriores ao Programa podendo existir, de forma permanente, antes e depois da sua execução.

Como declarar um ficheiro de tipo texto:

var ficheiro:texto;

assign(ficheiro,’texto1.txt’);

rewrite(ficheiro);

write/writeln(ficheiro,dado);

close(ficheiro);

reset(ficheiro);

read/readln(ficheiro,dado);

append(ficheiro,dado);

Como declarar um ficheiro do tipo definido pelo programador:

Type a=record

          b:string;

end;

var fichg:a;

      ficheiro:file of  fich;

assign(ficheiro,’registos.dat’);

rewrite(ficheiro);

write(ficheiro,dado);

close(ficheiro);

reset(ficheiro);

read(ficheiro,dado);



Reflexão:

Neste módulo aprendi o conceito de ficheiros e a declarar ficheiros do tipo texto e ficheiros definidos pelo programador. Aprendi as diferenças entre cada um deles.

Uma das características dos ficheiros dos ficheiros do tipo texto é que depois do ficheiro estar criado podemos ver o seu conteúdo e nos ficheiros definidos pelo programador a informação fica encriptada.   

Reflexão Final do Módulo 6

Nesta reflexão constam todos os conteúdos, de uma forma resumida, que foram abordados ao longo do módulo 6 na disciplina de Programação de Sistemas Informáticos.

Ao longo deste módulo aprendi o conceito de ponteiros, pois seria com eles que iria trabalhar ao longo de todo o módulo. Em seguida realizei pequenos programas para aprender a utilizar os ponteiros.

Depois de sabermos minimamente trabalhar com ponteiros passamos para as pilhas, que são um tipo de estruturas dinâmicas pois permitem poupar memória e eliminar dados. Realizei vários exercícios que me ajudaram a perceber melhor as pilhas.

Depois de várias aulas a trabalhar com pilhas passamos para as filas, também elas um tipo de estruturas dinâmicas. Ao longo deste tema efectuei vários exercícios que me serviram de auxílio para aprender a trabalhar com filas.

Em seguida passamos para a parte mais difícil mas mais importante, as listas ordenadas, que permitem remover elementos em qualquer parte da lista. Para mim foi o tema mais difícil deste módulo mas percebi tudo muito bem pois realizei vários exercícios que facilitaram a minha aprendizagem. 

O que são estruturas dinâmicas?

Em programação, uma variável ou estrutura de dados diz-se dinâmica quando pode ser criada e destruída no decurso de um programa, consoante as necessidades de tratamento de informação.

Existem 3 tipos de estruturas dinâmicas:

• Pilhas

É uma estrutura de dados que corresponde a uma lista sequencial. Respeita a propriedade LIFO (Last In First Out), ou seja, o último a entrar é o primeiro a sair.

Program Pilha ;

type dados=record

                nome:string;

                idade:integer;

                prox:^dados;

end;

var p1,px:^dados;

    x:char;

    y,i:integer;

procedure inserir;

Begin

      p1:=nil;

                new(px);

                writeln('Nome: ');

                read(px^.nome);

                writeln('Idade: ');

                read(px^.idade);

                px^.prox:=p1;

                p1:=px;

end;

procedure listar;

begin

px:=p1;

repeat

                writeln('Nome: ',px^.nome);

                writeln('Idade: ',px^.idade);

                px:=px^.prox;

until px=nil;

end;

procedure eliminar;

begin

px:=p1;

if px<>nil then

                begin

                               p1:=px^.prox;

                               dispose(px);

     end

else

                writeln('Pilha vazia');

end;

begin

                p1:=nil;

     repeat

                writeln('1-para inserir dados.');

                writeln('2-para mostrar dados.');

                writeln('3-para eliminar dados.');

                writeln('Qual a opoção');

                read(y);

                case y of

                               1:inserir;

                               2:listar;

                               3:eliminar;

                end;

                               writeln('Deseja continuar?(S-N)');

                               read(x);

                until(x='n') or (x='N');   

 End.

• Filas

Os elementos entram sempre na cauda da estrutura e o próximo elemento a sair é sempre o que se situa na frente da fila. Respeita a propriedade FIFO (First In First Out), ou seja, o primeiro a entrar é o primeiro a sair.

Program fila ;

type pessoa=record

                nome:string;

                idade:integer;

                peso:real;

                prox:^pessoa;

end;

var cauda,frente,px:^pessoa;

    x:char;

    y:integer;

 procedure inserir;

 begin

                new(px);

                writeln('Nome:');

                read(px^.nome);

                writeln('Idade:');

                read(px^.idade);

                writeln('Peso:');

                read(px^.peso);

                if frente=nil then

                begin

                               frente:=px;

                               cauda:=px;

                end

                else

                begin

                               cauda^.prox:=px;

                               cauda:=px;

                               cauda^.prox:=nil;

                end;

 end;

 procedure percorrer;

 begin

                px:=frente;

                if px=nil then

                               writeln('Pilha vazia')

                else

                begin

                               repeat

                                               writeln('Nome: ',px^.nome);

                                               writeln('Idade: ',px^.idade);

                                               writeln('Peso: ',px^.peso);

                                               px:=px^.prox;

                               until (px=nil);

                end;

 end;

 procedure eliminar;

 begin

                px:=frente;

                if px=nil then

                               writeln('Pilha vazia')

                else

                begin

                               px:=frente;

                               frente:=frente^.prox;

                               dispose(px)

                end;

 end;    

 Begin

      cauda:=nil;

      frente:=nil;

      repeat

                writeln('1-para inserir dados.');

                writeln('2-para mostrar dados.');

                writeln('3-para eliminar dados.');

                writeln('Qual a opoção');

                read(y);

                case y of

                               1:inserir;

                               2:percorrer;

                               3:eliminar;

                end;

                               writeln('Deseja continuar?(S-N)');

                               read(x);

                until(x='n') or (x='N');   

 End.

• Listas Ordenadas

Os elementos devem ficar por ordem alfabética ou por ordem crescente ou decrescente dos seus valores. Neste caso podemos remover um elemento em qualquer lugar da lista. 

Program lista_ordenada;

type lista=record

                nome:string;

                ponteiro:^lista;

end;

var px,pz,p1,p2:^lista;

    escolha, OP:char;

procedure inserir;            

 Begin

                new(px);

                writeln('Introduza o nome');

                read(px^.nome);

                px^.ponteiro:=pz;

                pz:=px;  

 End;

 procedure listar;

 begin

  px:=pz;

   If px=nil then

                  writeln('A lista está vazia')

   else

                  begin

                                  repeat

                                                 writeln('Nome - ', px^.nome);

                                                 px:=px^.ponteiro

                                 until px=nil;

                  end;

 end;

 procedure ordenar;

 var trocar: boolean;

 aux:string;

 begin

 P1:=Pz;

 P2:=Pz^.PONTEIRO;

                IF (pz <> nil) and (pz^.ponteiro <> nil) then

                               repeat

                                               trocar:=false;

                                               p1:=pz;

                                               p2:=pz^.ponteiro;

                                               repeat

                                                                              if p1^.nome>p2^.nome then

                                                                                              begin

                                                                                                              trocar:=true;

                                                                                                              aux:=p1^.nome;

                                                                                                              p1^.nome := p2^.nome;

                                                                                                              p2^.nome:=aux;

                                                                                              end;

                                                                                              p1:=p1^.ponteiro;

                                                                                              p2:=p2^.ponteiro;

                                                               until p1^.ponteiro = nil;

                               until not trocar

                else

                               begin

                                               if p1=nil then

                                                               writeln('Lista vazia');

                                               if p1^.ponteiro=nil then

                                                               Writeln('Só existem 1 elementos');

                               end;                                                                                                                  

 end;

 procedure remover;

 var pa:^lista;dado:string;

 begin

                if pz<>nil then

                begin

                               writeln('Introduza o dado a eliminar');

                               read(dado);

                               pa:=nil;

                               px:=pz;

                               while (px<>nil) and (px^.nome<>dado) do

                               begin

                                               pa:=px;

                                               px:=px^.ponteiro;

                               end;

                               if px=nil then

                                               writeln(dado,' não se encontra na lista')

                               else

                                               begin

                                                               if pa=nil then    

                                                                              pz:=px^.ponteiro

                                                               else

                                                                              pa^.ponteiro:=px^.ponteiro;

                                               dispose(px);

                                               writeln(dado,' foi removido da lista');

                                               end;

                end

                else

                               writeln('Lista vazia');

 end;    

 begin

                pz:=nil;

                               repeat

                                               writeln('1-Inserir');

                                               writeln('2-Listar');

                                               writeln('3-Sair');

                                               writeln('4-Apagar');

                                               writeln('Qual a opção?');

                                               readln(op);

                                                               case op of

                                                                              '1':Begin inserir; ordenar; end;

                                                                              '2':listar;

                                                                              '4':remover;

                                                               end;

                                               writeln('Deseja continuar??');

                                               Readln(escolha);

                               until(escolha='N') or (escolha='n');

 end.

Nota: Para preencher uma lista ordenada utiliza-se o mesmo processo que utiliza para uma pilha.

Reflexão:

As estruturas dinâmicas foram a base deste módulo. Aprendi a realizar filas, pilhas e listas ordenadas.