Reflexão ao modulo 8

Eu neste módulo, que foi de teórica fiquei a entender o que é o POO, programação orientada a objectos, programação não estruturadas, programação estruturada, polimorfismo, herança e encapsulamento. Para eu perceber melhor estes conceitos teóricos, eu coloquei no portefólio esses conceitos que me ajudaram e vão ajudar ainda mais quando eu precisar. 

Herança -> são classes que podem ser criados com base em outras classes, herdando os seus membros.

Polimorfismo -> é um determinado método de uma classe ou conjunto de classe que pode ter varias versões ou formas.

Programação orientada por objectos -> permite trabalhar com aplicações para ambientes graficos como o Microsoft, Windows, Linux, etc.

Ex.: C++; Java; JavaScritp; PHP; ASP.

Programação nao estruturada -> só permite sequências lineares de introduções.

EX.: Basic; Fortram; ect.

Encapsulamento -> são as classes e os objectos que são unidades de código que encobrem e protegem os seus membros em relação á classe membros.

Programação estruturada ->  tem estruturas de controlo(if...then; case; while; for; etc.) e tambem a divisão dos programas em rotinas ou em subprogramas(procedimentos ou função);
   
    EX.: Pascal; C; etc.

Como se designa-se uma classe no contexto do POO

Uma classe no contexto do POO é uma unidade de código a partir da qual se podem criar objectos de programação, e os objectos são unidades  de código utilizados no desenvolvimento de aplicações.

Conceitos avançados de programação

POO

Na programção orientada a objectos, o conceito central é o de objecto, mas tambem podia ser o de classe.

Uma classe, no contexto da POO, é uma unidade de código a partir da qual se podem criar objectos de programação.

Ficha nº1

Program ficheiro_de_inteiros ;
var fich:file of integer;
    n,x,e:integer;
    i:char;

Procedure criar_ficheiro;
 begin
 begin
      assign(fich,'artigos.dat');
      rewrite(fich);
  end;
  close(fich);
  end;

Procedure introduzir_valores;
 begin
              writeln('introduza primeiro valor');
              readln(x);
 end;

Procedure ler_ficheiro;
begin
 begin
          reset(fich);
      writeln('listagem dos valores do ficheiro');
      writeln('ha',filesize(fich),'valores no ficheiro');
      while not Eof(fich) do
       begin
         read(fich,x);
             write(x);
       end;
      writeln('tecla <enter> para  prosseguir');
      readln;
 end;
 close(fich);
 end;
Procedure Pesquisa_de_um_elemento_do_ficheiro;
 begin
  begin
      writeln('consulta de um valor por posicao no ficheiro');
     writeln('qual o posicao o procurar');
     readln(n);
     Seek(fich,n-1);
     read(fich,e);
     writeln('o valor : ',e);
     writeln('tecla <enter> para prosseguir');
     readln;
 end;
 close(fich);
 end;

 begin
      repeat
           writeln('xxxx Menu xxxx');
          writeln('criar_ficheiro -->1');
          writeln('Introduzir valores -->2');
          writeln('ler_ficheiro -->3');
          writeln('pesquisa_de_um_elemento_do_ficheiro -->4');
          writeln('teminaprograma -->0');
          readln(i);
          case i of
                  '1':criar_ficheiro;
              '2':introduzir_valores;
              '3':ler_ficheiro;
              '4':pesquisa_de_um_elemento_do_ficheiro;
              '0':writeln('fim');
           end;
     until i='0' ;
 end.

 Ficha nº3

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);
        read(fich,parque);
    maior:=parque.tempo;
    mat:=parque.matricula;
    while not eof (fich) do
        begin
                read(fich,parque);
            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);
    while not eof (fich) do
        begin
                read(fich,parque);
            if parque.matricula=matri then
                begin
                    Writeln('MARCA');readln();
                    readln(parque.marca);
                    writeln('Matr¡cula');
                    readln(parque.matricula);
                    writeln('Tempo estacionado');
                    readln(parque.tempo);
                                        seek(fich,filepos(fich)-1);
                    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.

        Ficheiros do tipo texto

 1-Declaração de variavais  ->   var ficheiro: text;
 2-Associar  ->  assign(ficheiuro,'texto1.txt');
 3-Criação de ficheiro  ->  rewriteln(ficheiro);
 4-Escrever no ficheiro  ->  write / writeln(ficheiro,dado);
 5-Fechar o ficheiro  ->  close(ficheiro);
 6-Abrir ficheiro  ->   reset(ficheiro);
 7-Ler no ficheiro  ->  read / readln(ficheiro,dado);
 8-Acrescenta  ->  append(ficheiro,dado); 
 

Refleção ao modulo 6

Nesta refleção vou falar sobre os programas que eu introduzi no meu blogge. Eu no início deste modulo eu não tinha percebido o significado de ponteiro, mas ao longo da matéria fiquei a perceber melhor a matéria dada. O programa que eu meti ajudou-me a compreender melhor a matéria. No programa da pilha eu fiquei a entender os procedure inserir e mostrar. Nos programa da fila e da lista ordenada fiquei a perceber melhor os procedure eliminar, ordenar e lista ordenada, por isso que eu ao longo dos programas que nos fizemos eu fiquei a perceber a matéria que nos demos.

Esquema da lista ordenada

Programa da lista ordenada

Program lista_ordenada ;
type nada = string[20];
     Tipo_A = ^Tipo_B;
 Tipo_B = Record
 info : Nada;
 Prox : Tipo_A;
end;
Var pi : Tipo_A;
    opcao,x : char;
 Procedure Inserir;
    Var px : Tipo_A;
       Begin
            New(px);
            writeln('Inserira um nome');
            Readln(px^.info);
            px^.prox:=pi;
            pi:=px;
            Writeln('O dado foi introduzido com sucesso');
       end;

 Procedure Listar;
     Var Px : Tipo_A;
   Begin
        Writeln;
    px:=pi;
    If (px=nil) then
        Writeln('lista vazia')
    else
       begin
    While(px<>nil) do
      Begin
          Writeln(px^.info);
      px := px^.prox;
      end;
    end; 
   end;
 Procedure Ordenar;
     Var p1,p2:Tipo_A;
     Trocar:boolean;
     aux :nada;
   Begin
        p1:=pi;
    p2:=pi^.prox;
        If (p1<>nil) and (p1^.prox<>nil) then
    repeat
          Trocar:=false;
      p1:=pi;
      p2:=pi^.prox;
      Repeat
        If (p1^.info > p2^.info) then
      Begin
           Trocar:=true;
       aux:=p1^.info;
       p1^.info:=p2^.info;
       p2^.info:=aux;
          end;
      p1:=p1^.prox;
      p2:=p2^.prox;
      until p1^.prox=nil;
    until not trocar;
   end;
 Procedure Remover;
   Var px:Tipo_A;
       pa:Tipo_A;
       dado:Nada;
      
   begin
        If pi<>nil then
     begin
          writeln('->Escreva o dado a excluir na lista');
      readln(dado);
      px:=pi;
      pa:=nil;
      While (px<>nil) and (px^.info<>dado) do
      begin
           pa:=px;
           px:=px^.prox;
      end;
      If px = nil then
         writeln('O dado nao se encontra na lista')
      else
          begin
        If pa=nil then
       pi:=px^.prox
    else
       begin
          pa^.prox:=px^.prox;
      dispose(px);
      writeln(dado,'foi removido com sucesso');
       end;
      end;
     end;
   end;                      
      
begin
     pi:=nil;
 Repeat
      writeln('____Menu____');
  writeln;
  writeln('Inserir ---> 1');
  writeln('listar ---> 2');
  writeln('Remover---> 3');
  writeln('Sair--->0 ');
  writeln('qual é a sua opção');
  readln(opcao);
  Case opcao of
      '1':begin Inserir; Ordenar; end;
      '2':Listar;
      '3':Remover;
      '0':writeln('Fim do programa');
  end;
 until (opcao='0');
end.                     

Esquema da fila

Programa da pilha


program fila ;
type nada = record
     nome:string;
 idade:integer;
 peso:integer;
 prox:^nada;
end;
var cauda:^nada;
    px:^nada;
    frente:^nada;
    x:integer;
    n:char;
 procedure inserir;
    begin
             new(px);
             writeln('introduza um nome');
             readln(px^.nome);
             writeln('introduza a idade');
             readln(px^.idade);
             writeln('introduza o peso');
             readln(px^.peso);
         if (frente=nil) then
           begin
             px:=cauda;
             px:=frente;
           end   
         else
       begin
             cauda^.prox:=px;
             cauda:=px;

           end;   
    end;

 Procedure eliminar;
    begin
     if (frente=nil) then
         writeln('nao existe nada')
     else
         px:=frente;
     frente:=frente^.prox;
     dispose(px);
    end;
 procedure mostrardados;
    begin
     if (frente = nil) then
         writeln('nao exite nada')
     else
         repeat
          writeln(px^.nome);
          writeln(px^.idade);
      writeln(px^.peso);
      px:=px^.prox;
     until(px = nil);
    end;
 begin
   cauda:=nil;
   frente:=nil;
  repeat
        writeln;
        writeln('****Menu****');
        writeln('1-inserir ');
    writeln('2-eliminar ');
    writeln('3-mostrardados ');
    writeln('4-sair ');
     readln(x);
    case n of
          '1': inserir;
      '2': eliminar;
      '3': mostrardados;   
            end;
  until ( x = 4);
 end.                       

Esquema da pilha

Pilha


Program Pilha  ;
type nada = record
     nome:string[10];
idade:integer;
ano:^nada;
end;
var p1:^nada;
    px:^nada;
    n:integer;
 Begin
      p1:=nil;
      for n:=1 to 10 do
      begin
         new(px);
         writeln('insira um nome para da lista');
         readln(px^.nome);
         writeln('insira a idade para o nome da pessoa que introduziu');
         readln(px^.idade);
   px^.ano:=p1;
   p1:=px;
      end;
while(px<>nil) do
   begin
      writeln(px^.nome);
 writeln(px^.idade);
 px:=px^.ano;
   end;  
 End.

O que são ponteiros? 

O ponteiro é uma variavel que é capaz de receber um endereço de memoria Ram relativa a um determinado tipo de dados.