Lab1 Tiago Porto

aluno: Tiago Porto Barbosa
ano/sem: 2008/2o.
data do laboratório (2) : 06/08/2008 (2)

Introdução

Esse laboratório teve como objetivo ter um primeiro contato com o paradigma de orientação a objetos. Para isso, foi desenvolvido um pequeno programa que simula a execução e entrega de relatórios (de laboratório) por alunos a um professor. A medida que os alunos terminam seus relatórios, vão colocando-os numa "Fila de Entrega" (pode ser a fresta da porta da sala do professor). O professor corrige os relatórios na ordem em que foram entregues a ele, divulgando a nota.

Foi utilizada a linguagem Java com ambiente de desenvolvimento BlueJ.

Desenvolvimento

CLASSES

As classes criadas foram:

Classe (abstrata) aluno:
Esse classe será uma super classe abstrata para os dois tipos possiveis de alunos: do tipo AlunoEsforcado e do tipo AlunoSafoPreguicoso.
Cada aluno tem 4 atributos acessíveis externamente (getConhecimento, getInteligencia, getDedicacao, getNome ) e um metodo que simula a execução e entrega de um relatorio. Os métodos getInteligencia e getDedicacao são abstratos (devem ser obrigatoriamente sobrescritos na subclasse).
Um aluno está relacionado a um pilha.

public abstract class Aluno{
    int conhecimento = 0;
    String nome = new String();
    RelaQueue queue;
    public Aluno(String nome, RelaQueue queue){
        /* Metodo construtor da classe Aluno */
        this.nome = nome;
        this.queue = queue;
    }
    public void fazEEntregaRelatorio(){
        /* Calculo dos atributos do relatorio */
        double qualidade = (2 * this.getDedicacao() + 1 * this.getInteligencia() ) / 3 ;
        double originalidade = (1 * this.getDedicacao() + 2 * this.getInteligencia() ) / 3 ;
        /* Criacao de um novo relatorio */
        Relatorio rela = new Relatorio(qualidade, originalidade, this);
        /* Empilha o relatorio criado */
        queue.queue(rela);
    }
    public int getConhecimento(){
        return conhecimento;
    }
    /* getInteligencia() e getDedicacao() sao metodos abstratos */
    public abstract double getInteligencia();
    public abstract double getDedicacao();
    public String getNome(){
        return nome;
    } 
}

Classe AlunoEsforcado
AlunoEsforcado é uma subclasse de Aluno, onde os atributos 'dedicacao = 1' e 'inteligencia = 0.5'.

public class AlunoEsforcado extends Aluno
{
    double inteligencia = 0.5;
    double dedicacao = 1;
    public AlunoEsforcado(String nome, RelaQueue queue){
        /* O construtor da classe AlunoEsforcado herda da clase Aluno */
        super(nome, queue);
    }
    public double getInteligencia(){
        return inteligencia;
    }
    public double getDedicacao(){
        return dedicacao;
    }
}

Classe AlunoSafoPreguicoso
AlunoSafoPreguicoso herda da classe Aluno, com os atributos 'inteligencia = 1' e a dedicacao é um valor aleatorio de 0 a 0.5.

import java.util.*; // Ramdon();
 
public class AlunoSafoPreguicoso extends Aluno
{
    double inteligencia = 1;
    public AlunoSafoPreguicoso(String nome, RelaQueue queue){
        /* O construtor da classe AlunoSafoPreguiçoso herda da clase Aluno */
        super(nome, queue); 
    }
    public double getInteligencia(){
        return inteligencia;
    }
    public double getDedicacao(){
        return generateRandomDe0aMeio();
    }
    private double generateRandomDe0aMeio()
    {
        /* Metodo que retorna um valor aleatorio de 0 a 0.5 */
        Random generator = new Random();
        double r = generator.nextDouble();
        return r * 0.5;
    }
}

Classe RelaQueue
Classe que simula uma pilha onde o professor vai guardar os relatórios que os alunos fazem e depois corrige todos. A pilha tem o limite de 10 relatórios.

public class RelaQueue
{
    /* pilha e um array de no maximo 10 relatorio */
    Relatorio[] pilha = new Relatorio[10];
    int inicio = 0;
    int fim = 0;
    public void queue(Relatorio rela){
        /* Metodo que empilha um relatorio no final da pilha */
        pilha[fim] = rela;
        fim = (fim + 1) % 10;
    }
    public Relatorio dequeue(){
        /* Metodo que desempilha um relatorio do inicio da pilha e retorna null
         * quando esta vazia */
        if (inicio!=fim){
            Relatorio valor = pilha[inicio];
            inicio = (inicio + 1) % 10;
            return valor;
        } else {
            return null;
        }
    }
}

Classe Relatorio
Classe que represanta um relatório.
Cada relatório tem qualidade, originalidade e aluno associoados a ele. Um relatório é feito por um único aluno.

public class Relatorio{
    double qualidade;
    double originalidade;
    Aluno aluno;
    public Relatorio(double qualidade, double originalidade, Aluno aluno){
        /* Metodo construtor da classe Relatorio */
        this.qualidade = qualidade;
        this.originalidade = originalidade;
        this.aluno = aluno;       
    }
    public double getQualidade(){
        return qualidade;
    }
    public double getOriginalidade(){
        return originalidade;
    }
    public Aluno getAluno(){
        return aluno;
    }
}

Classe Professor
Classe que representa um professor corrige todos os relatorios de uma pilha associada a ele. Um professor só se acossia com uma unica pilha de relatórios.
Para dar a nota para um relatorio, o professor tira a media aritmetica com a qualidade e originalidade do relatorio mais um fator aleatorio, multiplicando todo por 10.
Após corrigir, os nomes e notas dos alunos são impressos na tela.

import java.util.*; /* Random() */
 
public class Professor {
    RelaQueue queue;
    public Professor(RelaQueue queue){
        /* Metodo construtor da classe Professor*/
        this.queue = queue;
    }
    private double corrigirRelatorio(Relatorio rela){
        /* Calculo da nota de um relatorio */
        double nota = ( rela.getQualidade() + rela.getOriginalidade() + this.fatorAleatorioDe0a1() ) / 3 * 10;
        return nota;
    }
    public void corrigirRelatorios(){
        Relatorio rela = queue.dequeue();
        /* Corrige os relatorios ate a pilha ficar vazia */
        while (rela!=null){
            System.out.println(rela.getAluno().getNome()+": "+corrigirRelatorio(rela));
            rela = queue.dequeue();
        }
    }
    private double fatorAleatorioDe0a1(){
        /* Metodo que gera um numero aletorio de 0 a 1 */
        Random generator = new Random();
        double r = generator.nextDouble();
        return r;
    }   
}

Desse modo, ss diagramas de classes compilado no BlueJ fica assim:
lab1

Classe Teste e Resultados

Para testar o programa com todas as classe prontas, foi classe de testes e em um método de teste público, com o nome testAluno. Este código cria 4 alunos, um professor, manda os alunos fazer os relas e mandar o professor corrige os relas. Ao final da execução exibe uma tela com a nota do relatório de 3 destes 4 alunos.

public class Teste extends junit.framework.TestCase
{
    public void testLouco(){
        RelaQueue queue = new RelaQueue();
        Professor prof = new Professor(queue);
        AlunoEsforcado aluno1 = new AlunoEsforcado("John Smith", queue);
        AlunoEsforcado aluno2 = new AlunoEsforcado("Mark Smith", queue);
        AlunoSafoPreguicoso aluno3 = new AlunoSafoPreguicoso("Joseph Smith", queue);
        AlunoSafoPreguicoso aluno4 = new AlunoSafoPreguicoso("Robert Smith", queue);
 
        //teste de alunoesforcado
        assertEquals(0.5, aluno1.getInteligencia(), 0.01);
        assertEquals(1, aluno1.getDedicacao(), 0.01);
 
        //teste de alunosafo
        assertEquals(1.0, aluno3.getInteligencia(), 0.01);
        assertTrue(aluno3.getDedicacao() != aluno3.getDedicacao()); //deve ser randomica
        assertTrue(aluno3.getDedicacao() < 0.5);
 
        //alunos comecam a fazer os relas
        aluno1.fazEEntregaRelatorio();
 
        //roubamos o relatório do primeiro aluno para investigá-lo
        Relatorio rela1 = queue.dequeue();
        assertEquals(aluno1, rela1.getAluno());
        assertTrue(rela1.getAluno().getNome().equals("John Smith"));
        assertTrue(rela1.getQualidade() < 0.9);
        assertTrue(rela1.getQualidade() > 0.8);
        assertTrue(rela1.getOriginalidade() < 0.7);
        assertTrue(rela1.getOriginalidade() > 0.6);
 
        //os outros continuam a fazer os relas
        aluno2.fazEEntregaRelatorio();
        aluno3.fazEEntregaRelatorio();
        aluno4.fazEEntregaRelatorio();
 
        //deve exibir a coreção dos relas dos aluno2, aluno3, e aluno4, nesta ordem
        //pois "roubamos" o relatório do aluno1
        prof.corrigirRelatorios();
    }
}

O resultado da classe de teste fica assim:

lab1-1 lab1-2

Testando manualmente o programa

Para mostrar como testar o programa sem precisar criar uma classe de teste, e nem precisar ir na linha de comando, mostrarei alguns testes que podem ser feito com o mouse (clicando com o botão direito).

Criar um objeto relas da classe RelaQueue:
m1.jpg
m2.jpg

Criar um objeto prof da classe Professor:
m3.jpg
m4.jpg

Criar dois objetos: tiago e aline da classe AlunoEsforcado:
m5.jpg
m6.jpg
m7.jpg

Criar dois objetos: misael e caio da classe AlunoSafoPreguicoso:
m8.jpg
m9.jpg
m10.jpg

Testar os métodos getAtributo dos alunos, conferindo com os valores esperado:
m11.jpg
m12.jpg
m13.jpg

porto é da classe AlunoEsforcado, então sua inteligência é 0.5, sua dedicação é 1.
m14.jpg
m15.jpg

misael é do tipo AlunoSafoPreguicoso, então sua inteligencia é 1 e sua dedicação está entre 0 e 0.5
m16.jpg
m17.jpg

Testar o método corrigirRelatorios do prof:
m18.jpg

Resultado impresso após corrigir todos os relatórios, com nome e nota dos alunos:
m19.jpg

Testar o método dequeue de relas, que irá retornar o valor null pois não há relatórios empilhados após a correção:
m20.jpg
m21.jpg

Codigo anexado
Todos os arquivos para BlueJ

Conclusão

Com esse trabalho, houve o primeiro contato com a liguagem Java utilizando para isso um ambiente de desenvolvimento bem didatico BlueJ. Serviu também pra mostrar os primeiros conceitos de orientação a objeto como classes, objetos, métodos, herança, classe abstratas, vistos em sala, além de mostrar uma classe muito importante para realizar testes.
Uma dificuldade presente durante a realização desse pequeno projeto foi a falta de intimidade com a liguagem, fazendo com que as ideias ficassem um pouco obscuras no começo, mas clareando durante o desenvolvimento.
Uma duvida era saber como um construtor de uma subclasse era feito através de uma super-classe: utilizando super().
Lembrando que todos os testes feitos manualmente poderiam ser feitos usando a linha de comando, mas foi escolhido esse modo para servir de tutorial para usar o BlueJ.
Apesar dos imprevistos, o exercício foi um sucesso!! =)

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