Lab1 Alexandre Albizzati

aluno: Nome do Aluno
ano/sem: 2008/2o.
data do laboratório (num. da semana) : 06/08/2008 (2)

Introdução

A idéia deste primeiro laboratório foi criar um programa em que fosse implementado um algoritmo de fila, que serviria para controlar um "fluxo de relatórios". Os "personagens" presentes no desenvolvimento deste projeto foram: alunos (de dois tipos), um professor, os relatórios dos alunos e uma única fila de relatórios.
Os alunos geram relatórios que são introduzidos na fila de relatórios. O professor, por sua vez, corrige os relatórios, esvaziando a fila.

Desenvolvimento

Segundo uma a filosofia de orientação a objetos, os "personagens" citados no tópico acima são na realidade classes.
Para a implementação do Lab1, foi necessário a criação de 6 classes, e uma classe de teste. Dentre as 6 classes do programa propriamente dito, temos uma classe abstrata (classe Aluno), da qual temos as classes AlunoSafoPreguicoso e AlunoEsforcado como suas subclasses.
Além destas, tivemos as classes RelaQueue, Professor e Relatorio.
As três figuras que se seguem são os resultados obtidos nos testes.

Abaixo é mostrada a figura com o resultado do teste realizado via classe testAluno:
imagem1.PNG

Esta imagem mostra o teste sendo implementado sem o uso da classe testAluno. Neste screenshot, estou fazendo o aluno gerar um relatório com fazEEntregaRelatorio():
imagem2.PNG

Resultado do teste realizado sem o uso da classe testAluno:
imagem3.PNG

—> Classe RelaQueue
Todo o "fluxo" dos relatórios é controlado por um único objeto da classe RelaQueue.
A classe RelaQueue é responsável pelos métodos de inserção e deleção da fila de relatórios.
Esta classe terá, durante a execução do programa apenas uma instância, que deverá ser passada, como argumento, para o professor e todos os alunos.
Abaixo são mostrados os métodos queue() e dequeue().

// Método para inserção dos relatórios na fila
 
    public void queue(Relatorio elem)
    {
        // Maximo de 10 elementos
        if((fim+1)==inicio||(fim+1)==(inicio+10))
        {
            System.out.println("Fila cheia!");
        }
        else
        {
        // Se a fila não está cheia, então insere-se um relatório
            RelaArray[fim] = elem;
            fim = (fim + 1) % 10;
        }
    }
 
    public Relatorio dequeue()
    {
    // Método para a deleção de relatórios da fila
      Relatorio valor;
      valor = RelaArray[inicio];
      if(inicio!=fim)
      {
    // Retorna o relatório deletado (para o professor poder corrigir, usando este metodo)
      inicio = (inicio + 1) % 10;
      return valor;
      }
    // Se a fila já está vazia retorna nulo
      else return null;
 
    }

Esta classe possui ainda os métodos getInicio() e getFim() para acesso às posições da fila.

—> Classe Aluno
Esta é uma classe abstrata, isto é, não admite instâncias. Ela foi criada para suportar outras duas subclasses: AlunoSafoPreguicoso e AlunoEsforcado.
As variáveis de instância dessa classe são conhecimento (int), nome (String) e queue (RelaQueue).
Os métodos getDedicacao() e getInteligencia() são abstratos pois serão sobrescritos pelas subclasses.
Já o método fazEEntregaRelatorio() é implementado nesta classe (e portanto as subclasses o herdarão).

public void fazEEntregaRelatorio()
    {
        // Gera as variaveis que serão usada para o construtor do Relatorio
        double qualidade = (2 * this.getDedicacao() + 1 * this.getInteligencia() ) / 3 ;
        double originalidade = (1 * this.getDedicacao() + 2 * this.getInteligencia() ) / 3 ;
        Relatorio rela = new Relatorio(qualidade,originalidade,this);
        queue.queue(rela); // Enfileira o relatório criado
    }

Há ainda os métodos getConhecimento() e getNome() para acesso das propriedades.

—> Classe AlunoEsforcado e AlunoSafoPreguicoso

Estas duas classes são subclasses da classe Aluno.
Durante a execução do programa, pode-se criar várias instâncias destas duas classes. Cada instância poderá gerar um relatório, que por sua vez será corrigido pelo professor.
Abaixo são mostrados os métodos que elas sobrescrevem de Aluno:

Classe AlunoEsforcado:

public double getInteligencia()
    {
        return 0.5;
    }
 
    public double getDedicacao()
    {
        double dedicacao = 1;
        return dedicacao;
    }

Classe AlunoSafoPreguicoso:

public double getInteligencia()
    {
        double inteligencia = 1;
        return inteligencia;
    }
 
    public double getDedicacao()
    {
        Random generator = new Random();
        double r = generator.nextDouble();
        return r * 0.5;
    }

Os construtores dessas duas classes recebem o nome do aluno e a a única instância da classe RelaQueue, como argumentos.

—> Classe Professor

Esta classe gerará apenas uma instância.
O professor será o responsável por corrigir os relatórios gerados pelos alunos, esvaziando a fila que foi cheia pelo método fazEEntregaRelatorio(), dos alunos.
A classe Professor tem um método privado CorrigirRelatorio(), que é usado pelo seu outro método, CorrigirRelatorios(), sendo este último público.
O método CorrigirRelatorio() gera uma nota para o relatório de determinado aluno, baseado num fator aleatório associado à qualidade e originalidade do relatórios (propriedades do relatório, definidas na classe Relatorio).
Método privado CorrigirRelatorio():

private double corrigirRelatorio(Relatorio rela)
    {
        Random fatorAleatorioDe0a1 = new Random();
        double nota = ( rela.getQualidade() + rela.getOriginalidade() + fatorAleatorioDe0a1.nextDouble() ) / 3 * 10;
        return nota;
    }

O método CorrigirRelatorios() é público e é o método que de fato esvazia a fila de relatórios, imprimindo o nome dos alunos e suas respectivas notas. Ele é mostrado abaixo:

public void corrigirRelatorios()
    {
        int inicio = queue.getInicio();
        int fim = queue.getFim();
        Relatorio aux;
        while(true)
        {
           aux=queue.dequeue();
           if(aux==null) break;
           System.out.println(aux.getAluno().getNome()+ ": " + corrigirRelatorio(aux));
 
        }

—> Classe Relatorio

A classe relatório terá instâncias que serão criadas por alunos, em seguida enfileiradas em RelaQueue e depois esvaziadas pelo professor.
Abaixo é mostrado seu construtor e dois métodos to tipo GET:

public Relatorio(double Qualidade,double Originalidade,Aluno Aluno)
    {
        // Variáveis de instância
        qualidade = Qualidade;
        originalidade = Originalidade;
        aluno = Aluno;
    }
 
    // Métodos de Acesso a dados:
    public double getQualidade()
    {
        return qualidade;
    }
 
    public double getOriginalidade()
    {
        return originalidade;
    }
 
    public Aluno getAluno()
    {
        return aluno;
    }

Conclusão

De forma geral neste laboratório eu pude ter um primeiro contato com a linguagem Java e pela primeira vez pude programar sob a filosofia de orientação a objetos (pelo menos conscientemente).
Aprendi como as classes abstratas se relacionam com suas subclasses, compreendi melhor como funciona a relação entre classes e objetos e, finalmente, como tudo isso se integra para gerar um programa funcional.
Gostei do lab e achei com a dificuldade coerente com o que foi aprendido em sala de aula.

Add a New Comment
Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-ShareAlike 3.0 License