Lab2 Bruno Cesar

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.

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