aluno: Bruno César Alves
ano/sem: 2008/2o.
data do laboratório (num. da semana) : 06/08/2008 (2)
Introdução
Neste laboratório foram realizadas algumas refatorações no projeto do primeiro laboratório. Desta vez os alunos foram dividos em três tipos, de acordo com a sua faculdade. O comportamento dos alunos foi alterado de forma que seu comportamento (inteligência e dedicação) não faz mais parte da classe Aluno. Essas características agora pertencem à classe Comportamento e Aluno se tornou uma classe concreta.
A classe RelaQueue agora é subclasse de uma classe genérica Queue.
Desenvolvimento
Comportamento
A possibilidade da mudança de comportamento de um aluno com o passar do tempo nos faz pensar em uma forma de alterar sua inteligência e dedicação sem a destruição de uma instância de Aluno.
A forma utilizada neste laboratório foi a criação de uma nova classe abstrata Comportamento que tem como função agregar vários tipos de comportamento aos alunos sem que suas inteligências e dedicações sejam estáticas. Segue o código da classe comportamento:
public abstract class Comportamento // classe que explora o padrão Strategy { protected Aluno aluno; // guarda o aluno cujo comportamento está relacionado public Comportamento(Aluno aluno){ //construtor que define o aluno cujo comportamento está sendo relaciona this.aluno = aluno; } abstract public double getInteligencia(); //retorna a inteligencia de um comportamento abstract public double getDedicacao(); //retorna a dedicacao de um comportamento }
Foram definidas várias subclasses de Comportamento:
- Burro
- Pemba
- Imprevisível
- Summa
- SafoPreguiçoso
- Esforçado
Cada uma das subclasses define uma inteligência e uma dedicação específica para cada tipo de aluno. Segue o código de uma das subclasses:
public class Burro extends Comportamento { public Burro(Aluno aluno){ //construtor que chama o contrutor da superclasse super(aluno); } // funcoes que retornam a inteligencia e dedicacao do aluno cujo comportamento e burro public double getInteligencia(){ return 0; } public double getDedicacao(){ return 0; } }
Alunos de faculdades diferentes
Agora os alunos são divididos em três faculdade (subclasses da classe concreta Aluno): ITA, USP, Unicamp. Essa divisão possibilita não só a distinção entre as faculdade, mas também a restrição dos alunos em relação aos seus comportamentos.
Utilizando "Exception", foi possível aplicar as seguintes restrições aos tipos de alunos:
- Aluno do ITA nunca é burro
- Aluno da USP e Unicamp nunca são summa ou SafoPreguiçoso
As outras funcionalidades da classe Aluno foram mantidas. Segue o código da classe aluno e de uma de suas subclasses.
public class Aluno { protected Comportamento comportamento; //variavel que guarda o comportamento referente a uma instancia de aluno protected String nome; // guarda o nome do aluno protected RelaQueue queue; //guarda o queue que o aluno guarda seus relatorios protected double qualidade; // guarda a qualidade dos relatorios do aluno protected double originalidade; //guarda a originalidade dos relatorios do aluno public Aluno( String nome, RelaQueue queue){ //contrutor que define as variáveis do aluno this.nome = nome; this.queue = queue; comportamento = new Esforcado(this); this.qualidade = (2 * comportamento.getDedicacao() + 1 * comportamento.getInteligencia() ) / 3 ; this.originalidade = (1 * comportamento.getDedicacao() + 2 * comportamento.getInteligencia() ) / 3 ; } public void fazEEntregaRelatorio(){ // faz com que o aluno crie um relatorio e coloque na queue Relatorio relat = new Relatorio(this.qualidade,this.originalidade,this); queue.queue(relat); } public double getQualidade(){ // retorna a qualidade dos relatorios produzidos pelo aluno return qualidade; } public double getOriginalidade(){ //retorna a originalidade do relatorios produzidos pelo aluno return originalidade; } public String getNome(){// retorna o nome do aluno return nome; } public double getInteligencia(){ //retorna a inteligencia do aluno a partir do seu corpatamento return comportamento.getInteligencia(); } public double getDedicacao(){ //retorna a dedicacao do aluno a partir de seu comportamento return comportamento.getDedicacao(); } public void setComportamento(Comportamento comportamento) throws Exception { //define um comportamento para o aluno e analisa restricoes this.comportamento = comportamento; } }
public class AlunoITA extends Aluno { public AlunoITA(String nome, RelaQueue queue){ // chama o contrutor da superclasse super(nome,queue); } public void setComportamento(Comportamento comportamento) throws Exception { //cria uma exception if(comportamento instanceof Burro) throw new Exception(); //iteanos não são burros para os iteanos. super.setComportamento(comportamento); //define o comportamento para o aluno na superclasse } }
Anexe o arquivo com código nesta página.
Uso de genérico para o Queue
Foi criada uma classe genérica Queue que teve como objetivo apresentar o uso dos genéricos. Para que o resto do aplicativo não fosse prejudicado, a antiga classe RelaQueue se tornou uma subclasse de Queue com um código que simplesmente faz referência à Queue, de forma que todos as clamadas de funções que se referiam a RelaQueue continuassem válidas.
Segue o código da classe genérica Queue:
public class Queue<T> // classe generica para o RelaQueue { private T valor; //variavel generica private Object[] array = new Object[10]; // cria uma variavel de obejetos private int inicio, fim; // usadas para organizar a ordem do queue public void queue(T elem) { // coloca um objeto na fila array[fim] = elem; fim = (fim + 1) % 10; } public T dequeue(){ //tira um objeto na fila e da um cast para o tipo generico if(inicio == fim) return null; valor = (T) array[inicio]; inicio = (inicio + 1) % 10; return valor; } }
Simulador
O simulador foi criado para que o usuário possa criar alunos, fazer com que os alunos entreguem relatórios e que o professor os corrija. Segue o código do simulador:
import java.util.Scanner; class Simulador { protected static Aluno[] Alunos= new Aluno[50]; protected static int naluno; protected static RelaQueue queue = new RelaQueue(); protected static Professor professor = new Professor(queue); public static void main() { String input; Scanner scan = new Scanner(System.in); Professor professor = new Professor(queue); System.out.println("Deseja usar aplicação?(s/n)\n"); input = scan.next(); while(input.equals("s")){ System.out.println("Escolha uma das opções\n"); System.out.println("1.Cria aluno\n"); System.out.println("2.Fazer aluno entregar relatório\n"); System.out.println("3.Fazer professor corrigir relatório\n"); System.out.println("4.Sair\n"); input = scan.next(); if(input.equals("1")){ System.out.println("Digite o nome do aluno:\n"); input = scan.next(); criaraluno(input); input= "s"; } if(input.equals("2")){ System.out.println("Digite o nome do aluno:\n"); input = scan.next(); entrega(input); input= "s"; } if(input.equals("3")){ corrige(); input= "s"; } if(input.equals("4")){ input= "n"; } } } protected static void criaraluno(String nome){ Alunos[naluno] = new Aluno(nome,queue); naluno++; } protected static void entrega(String nome){ for(Aluno i : Alunos){ if (i!=null){ System.out.println(i.getNome()); if(i.getNome().equals(nome)){ i.fazEEntregaRelatorio(); } } } } protected static void corrige(){ professor.corrigirRelatorios(); } }
Conclusão
O laboratório foi realizado com sucesso. Em relação a classe genérica Queue foi encontrado um problema no uso de array para genéricos que pode ser substituído por uma outra forma apresentada em sala. O uso da classe Comportamento deixaram os alunos mais flexíveis. As subclasses que dividem os alunos em faculdades e o uso de "exception" solucionou de forma muito boa o problema das restrições.
Em relação ao comportamento, outra forma de solucionar o problema seria o uso de uma máquina de estados. Sua contrução seria mais trabalhosa, porém suas aplicações seriam maiores.
Faltou mostrar a classe Simulador antes das mudanças do lab2.
O termo correto é "refatoração" (alteração de um código já existente), não fatoração.