Lab1 Diego Alvarez

aluno: Diego Alvarez
ano/sem: 2008/2o.
data do laboratório (8.a semana) : 15/08/2008

Introdução

Neste laboratório foi criada uma pequena aplicação contendo 4 diferente tipos de entidades (Aluno, Professor, Relatorio, RelaQueue) relacionando-se através de um determinado contexto.
A implementação das entidades e de suas interações foi feita através do paradigma de orientação a objetos, implementando-se classes, heranças, encapsulamento, polimorfismo, associações e composições, dentre outros conceitos.
Ao fim da implementação, foi executado uma rotina de testes, disponibilizado pelo professor da disciplina, para verificar sua corretude.

Desenvolvimento

Classe RelaQueue:

import java.util.LinkedList;
 
/**
 * RelaQueue é a fila de entrega de relatórios ao professor.
 * Tanto os alunos quanto o professor devem saber onde está o objeto do tipo RelaQueue
 * do nosso sistema, para que possam, respectivamente, depositar e retirar os relatórios.
 * Portanto, devemos criar um RelaQueue primeiro e passá-lo aos objetos alunos e professor,
 * a medida que forem criados. Só haverá um objeto deste tipo na nossa aplicação.
 * 
 * @author Diego Alvarez
 */
public class RelaQueue{
 
    /**
     * Fila que armazena os relatorios dos alunos.
     */
    protected LinkedList<Relatorio> relaQueue = new LinkedList<Relatorio>();
 
    /**
     * Insere o elemento {@code relatorio} no final da fila.
     * Caso o tamanho da fila seja maior ou igual a dez, o relatorio
     * não é inserido
     * @param relatorio elemento a ser inserido na fila.
     */
    public void queue(Relatorio relatorio){
        if (relaQueue.size() < 10){
            relaQueue.add(relatorio);
        } 
    }
 
    /**
     * Retorna (e remove) o elemento à frente da fila.
     * @return o elemento que está à frente da fila, 
     * ou {@code null} caso a fila esteja vazia.
     */
    public Relatorio dequeue(){
        if (relaQueue.isEmpty()){
            return null;
        } else {
            return relaQueue.removeFirst();
        }
    }
}

Classe Relatorio:

/**
 * Representa os Relatórios, que são as entidades que são entregues pelos Alunos 
 * ao professor, através da fila de Relatórios (RelaQueue).
 * @author Diego Alvarez 
 */
public class Relatorio {
    protected Aluno aluno;
    protected float qualidade;
    protected float originalidade;
 
    /**
     * Constructor for objects of class Relatorio
     */
    public Relatorio(float qualidade, float originalidade, Aluno aluno){
        this.qualidade = qualidade;
        this.originalidade = originalidade;
        this.aluno = aluno;
    }
 
    /**
     * Getter do atributo qualidade
     * @return valor atributo qualidade
     */
    public float getQualidade(){
        return this.qualidade;
    }
 
    /**
     * Getter do atributo originalidade
     * @return valor atributo originalidade
     */
    public float getOriginalidade(){
        return this.originalidade;
    }
 
    /**
     * Getter do atributo aluno
     * @return valor atributo aluno
     */
    public Aluno getAluno(){
        return this.aluno;
    }
}

Classe Professor:

import java.util.Random;
 
/**
 * Representa o Professor, que é a entidade que recebe os Relatórios, através
 * da fila de Relatórios, e os corrige.
 * @author Diego Alvarez
 */
public class Professor {
 
    /**
     * Referência à fila de relatórios (única na aplicação)
     */
    protected RelaQueue relaQueue;
 
    /**
     * Construtor
     * @param relaQueue referência para a fila de relatórios. É atribuída ao atributo 'relaQueue'
     */
    public Professor(RelaQueue relaQueue){
        this.relaQueue = relaQueue;
    }
 
    /**
     * Metódo onde o Professor estabelece a nota de um Relatório recebido
     * 
     * @param relatorio Relatorio a ser corrigido
     * @return nota atribuída ao Relatorio
     */
    private float corrigirRelatorio(Relatorio relatorio){
        float nota = 
            ( relatorio.getQualidade() + relatorio.getOriginalidade() 
                    + (new Random()).nextFloat()) / 3 * 10;
        return nota;
    }
 
    /** 
     * Correção de todos os Relatórios da fila 
     */
    public void corrigirRelatorios(){
        Relatorio rela = relaQueue.dequeue();
        while (rela != null){
            System.out.println(rela.getAluno().getNome() + ": " +
                    + this.corrigirRelatorio(rela));
            rela = relaQueue.dequeue();
        }
    }
}

Classe Aluno:

/**
 * Representa os Alunos, que são as entidades que entregam os relatórios
 * ao professor.
 * 
 * @author (Diego Alvarez)
 */
public abstract class Aluno {
    /**
     * Referência à fila de relatórios (única na aplicação)
     */
    protected RelaQueue relaQueue;
 
    /**
     * Propriedade característica de um Aluno
     */
    protected int conhecimento = 0;
 
    /**
     * Propriedade característica de um Aluno
     */
    protected String nome;
 
    /**
     * Propriedade característica de um Aluno
     */
    protected float inteligencia;
 
    /**
     * Propriedade característica de um Aluno
     */
    protected float dedicacao;
 
    /**
     * Construtor
     * @param nome é atribuido ao atributo 'nome' do objeto Aluno em questão
     * @param relaQueue referência para a fila de relatórios. É atribuída ao atributo 'relaQueue'
     */
    public Aluno(String nome, RelaQueue relaQueue){
        this.nome = nome;
        this.relaQueue = relaQueue;
    }
 
    /**
     * Cria um novo objeto Relatorio e adiciona na fila de Relatórios
     */
    public void fazEEntregaRelatorio(){
        float qualidade = (2 * this.getDedicacao() + this.getInteligencia() ) / 3 ;
        float originalidade = (this.getDedicacao() + 2 * this.getInteligencia() ) / 3 ;
 
        Relatorio relatorio = new Relatorio(qualidade, originalidade, this);
        getRelaQueue().queue(relatorio);
        this.conhecimento ++;
    }
 
    /**
     * Getter do atributo relaQueue
     * @return valor atributo relaQueue
     */
    public RelaQueue getRelaQueue() {
        return relaQueue;
    }
 
    /**
     * Getter do atributo relaQueue
     * @return valor atributo relaQueue
     */
    public int getConhecimento(){
        return this.conhecimento;
    }
 
    /**
     * Getter do atributo relaQueue
     * @return valor atributo relaQueue
     */
    public String getNome(){
        return this.nome;
    }
 
    /**
     * Método Abstrato.
     * Este método é implementado nas subclasses da classe Aluno.
     */
    public abstract float getInteligencia();
 
    /**
     * Método Abstrato.
     * Este método é implementado nas subclasses da classe Aluno.
     */
    public abstract float getDedicacao();
}

Classe AlunoEsforçado:

public class AlunoEsforcado extends Aluno{
 
    /**
     * {@inheritDoc}
     */
    public AlunoEsforcado(String nome, RelaQueue relaQueue){
        super(nome, relaQueue);
        this.inteligencia = 0.5F;
        this.dedicacao = 1;
    }
 
    @Override
    public float getInteligencia(){
        return this.inteligencia;
    }
 
    @Override
    public float getDedicacao(){
        return this.dedicacao;
    }
}

Classe AlunoSafoPreguicoso:

import java.util.Random;
 
public class AlunoSafoPreguicoso extends Aluno{
 
    /**
     * {@inheritDoc}
     */
    public AlunoSafoPreguicoso(String nome, RelaQueue relaQueue){
        super(nome, relaQueue);
        this.inteligencia = 1;
    }
 
    @Override
    public float getInteligencia(){
        return this.inteligencia;
    }
 
    @Override
    public float getDedicacao(){
        this.dedicacao = 0.5F*(new Random()).nextFloat();
        return this.dedicacao; 
    }
}

Diagrama de Classes (BlueJ):

diagram.jpg

Resultado de uma execução da rotina de teste (BlueJ):
testResults.jpg

testeRun.jpg

Resultado de um dos testes manuais:
objetos.jpg
resultado_testes_manuais.jpg

Documentação (JavaDoc)
documentacao.jpg

Conclusão

No presente lab foram aplicados conceitos de programação orientada a objeto.
Para exemplificar, dentre os mais importantes, podemos citar:
1) Herança: AlunoSafoPreguicoso e AlunoEsforcado herdam da classe Aluno
2) Polimorfismo: A classe Aluno é uma classe abstrata com os métodos abstratos getInteligencia() e getDedicacao(), que são implementados nas subclasses da classe Aluno (AlunoSafoPreguicoso e AlunoEsforcado)
3) Encapsulamento: Exemplificado através de membros de diversas classe definidos como protected, sendo necessária (quando a classe que deseja o valor não é subclasse da classe que contém o atributo) a utilização de seus getters para acessar seu valor.
4) Associações: Aluno <-> RelaQueue / Professor <-> RelaQueue
5) Composições: RelaQueue <-> Relatorio

É observado no laboratório o fato da fila de relatórios possuir apenas uma instância durante todo o ciclo de vida da aplicação.
Para tanto, é criada uma única instância e passada sua referência para as classes que utilizarão a fila.
No entanto, uma melhor abordagem seria a implementação do padrão de projeto Singleton na classe RelaQueue, o qual garantiria a existência de uma única instância na aplicação, assim como facilitaria o acesso a tal instância pelas outras classes que a necessitam, através de um método estático getInstance() da classe RelaQueue, como visto em sala de aula.

A escolha por não utilizar setters nas implementações do encapsulamento das classes deve-se à tentativa de fidelidade máxima ao diagrama de classes exposto na descrição do laboratório, embora essa fidelidade não tenha ocorrido completamente em outras ocasiões.

Através dos comentários especiais ao longo do código foi possível gerar a documentação do aplicativo (JavaDoc), ilustrada com um printscreen no relatório e que pode ser completamente analisada na pasta 'lab1/doc', dentro da raíz do projeto BlueJ anexado à esta página.

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