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:
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:
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:
Criar um objeto prof da classe Professor:
Criar dois objetos: tiago e aline da classe AlunoEsforcado:
Criar dois objetos: misael e caio da classe AlunoSafoPreguicoso:
Testar os métodos getAtributo dos alunos, conferindo com os valores esperado:
porto é da classe AlunoEsforcado, então sua inteligência é 0.5, sua dedicação é 1.
misael é do tipo AlunoSafoPreguicoso, então sua inteligencia é 1 e sua dedicação está entre 0 e 0.5
Testar o método corrigirRelatorios do prof:
Resultado impresso após corrigir todos os relatórios, com nome e nota dos alunos:
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:
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!! =)
Código OK e rela muito bom.