Lab2 Anderson Aiziro

aluno: Nome do Aluno
ano/sem: 2008/2o.
data do laboratório (num. da semana) : 05/09/2008 (6)

Introdução

Este laboratório foi uma continuação do laboratório anterior. Utilizamos este laboratório para aperfeiçoar e conhecer novos conceitos de orientação a objetos. Além disso, vamos desenvolver uma classe simulador, que proporcionará um relacionamento com o usuário. Através de comandos de input e output, o usuário será capaz de criar quantos alunos quiser, especificando o tipo de aluno a ser criado, seu nome e a qual instituição ele pertence. Além disso, realizaremos o tratamento de exceções em java, para que a criação de alunos respeite algumas restrições. Por exemplo, não podemos ter um aluno do ita burro.
Finalmente, criaremos uma classe genérica Queue<T> para trabalhar com genéricos. Ou seja, não vamos restringir o conteúdo da fila a objetos do tipo Relatório.

Desenvolvimento

Inicialmente, criamos a classe Simulador para o laboratório anterior. O código fonte segue abaixo.

import java.io.*;
import java.util.*;
 
public class Simulador
{
    public static void main(String[] args) {
 
        Aluno[] alunosTeste = new Aluno[10];
        RelaQueue queue = new RelaQueue();
        Professor professor = new Professor(queue);
 
        String inputLine = null;
        int k;
        int escolha;
 
        try{
             BufferedReader is = new BufferedReader(new InputStreamReader(System.in));
             Scanner scan = new Scanner (System.in);
             k=0;
             while(true){
                System.out.println("Deseja adicionar um aluno (s/n): ");
                inputLine = is.readLine();
                if(inputLine.equals("n")) break;
 
                System.out.println("Digite o nome do aluno: ");
                inputLine = is.readLine();
                System.out.println("Entre com o tipo de aluno (1-Safo,2-Esforcado): ");
                escolha=scan.nextInt();
                if(escolha==1){
                    alunosTeste[k]=new AlunoSafoPreguicoso(inputLine,queue);
                }
                else{
                    alunosTeste[k]=new AlunoEsforcado(inputLine,queue);
                }
                alunosTeste[k].fazEEntregaRelatorio();
                k++;
 
             }
        }
         catch(IOException e){
             System.out.println("IOException"+e);
        }
        professor.corrigirRelatorios();
    }
}

O diagrama de classes com as modificações realizadas no primeiro lab segue abaixo. Dentre as principais mudanças, a classe Aluno deixa de ser genérica. Criamos uma classe Comportamento (genérico) que possui como subclasses, os diferentes tipos de comportamentos possíveis para um aluno. A classe Aluno apresenta como subclasses, os alunos de diferentes instituições.

diagrama.JPG

A classe Aluno deixa de ser genérico, e na criação de um novo aluno, estabelecemos inicialmente, seu comportamento como Esforcado. No método setComportamento, tratamos as exceções de modo que não seja possível criar alunos iteanos burros, por exemplo.

public class Aluno
{
    int conhecimento=0;
    String nome = new String();
    RelaQueue queue = new RelaQueue();
    Comportamento comportamento;
 
    public Aluno(String nome, RelaQueue queue){
        this.nome=nome;
        this.queue=queue;
        this.comportamento=new Esforcado(this);
    }
 
    void setComportamento(Comportamento comportamento) throws Exception {
        this.comportamento=comportamento;     
    }
 
    public int getConhecimento(){
        return this.conhecimento;
    }
 
    public String getNome(){
        return this.nome;
    }
    public void fazEEntregaRelatorio(){
        Relatorio rela = new Relatorio (getQualidade(),getOriginalidade(), this);
        queue.queue(rela);
        conhecimento++;
    }    
    double getQualidade(){
        double qualidade=(2*this.comportamento.getDedicacao()+ this.comportamento.getInteligencia() )/3;
        return qualidade;
    }
 
    double getOriginalidade(){
        double originalidade= (this.comportamento.getDedicacao()+ 2*this.comportamento.getInteligencia())/3;
        return originalidade;
    }  
 
    double getInteligencia(){
        return this.comportamento.getInteligencia();
    }
 
    double getDedicacao(){
        return this.comportamento.getDedicacao();
    }
 
}

As diferentes classes que controlam as instituições as quais o aluno pode pertencer possuem a mesma estrutura e os mesmos métodos, como exemplificado com a classe AlunoUnicamp abaixo. No método em que estabelecemos o comportamento do aluno, temos o controle das exceções, ou seja, é neste método que lançamos as exceções.

public class AlunoUnicamp extends Aluno
{
   public AlunoUnicamp(String nome, RelaQueue queue){
        super(nome,queue);
    }
 
    public void setComportamento(Comportamento comportamento) throws Exception {
        if(comportamento instanceof Summa) throw new Exception(); //alunos da unicamp não são summa!
        if(comportamento instanceof SafoPreguicoso) throw new Exception(); //alunos da unicamp não são safos,preguicosos
        super.setComportamento(comportamento); //faz o que a superclasse Aluno faz.
    }
 
}

A classe Comportamento será abstrata e possui os métodos abstratos getInteligencia() e getDedicacao() que serão descritas em cada uma das subclasses de Comportamento.

abstract class Comportamento {
    Aluno aluno;
 
    public Comportamento(Aluno aluno){
        this.aluno=aluno;
    }
 
    abstract double getInteligencia();
    abstract double getDedicacao();
}

As subclasses de Comportamento são: Summa, Pemba, Burro, Imprevisivel, SafoPreguicoso e Esforcado. Todos eles possuem a mesma estrutura, com os métodos getInteligencia(), getDedicacao() e o construtor. Um exemplo segue abaixo, a classe SafoPreguicoso.

import java.util.*;

class SafoPreguicoso extends Comportamento{
    double inteligencia=1;
    double dedicacao;

    public SafoPreguicoso(Aluno aluno){
        super(aluno);
    }

    double getInteligencia(){
        return this.inteligencia;
    }
    double getDedicacao(){
        return generateRandomDe0aMeio();
    }

    public double generateRandomDe0aMeio()
    {
        Random generator = new Random();
        double r = generator.nextDouble();
        return r * 0.5;
    }    
}

Agora, vamos criar uma classe genérica Queue<T>. Como a classe é genérica, não estamos restringindo o conteúdo interno da fila ao objeto do tipo relatório. Em seguida, com a classe Relaqueue, especificamos que o objeto criado em Queue é do tipo relatório. O código dessas duas classes segue abaixo:

public class Queue<T extends Object>  {

    private Object[] array  = new Object[10];
    private int inicio, fim;
    public void queue(T obj) {
        array[fim] = obj;
        fim = (fim + 1) % 10;
    }
    public T dequeue(){
      T valor = (T)array[inicio];

      if(inicio==fim){
          valor=null;
      }
      inicio = (inicio + 1) % 10;
      return valor;

    }
}

public class RelaQueue extends Queue<Relatorio> {
}

Temos finalmente, a classe Simulador. Nesta classe, temos uma interação com o usuário, que pode criar quantos alunos desejar, estabelecendo seu nome, instituição e comportamento. Caso ele tente criar um aluno com um comportamento proibído, uma mensagem de erro é enviada e o aluno não é criado.

import java.io.*;
import java.util.*;

public class Simulador
{
public static void main(String[] args) throws Exception {

        Aluno[] alunosTeste = new Aluno[10];
        RelaQueue queue = new RelaQueue();
        Professor professor = new Professor(queue);

        String inputLine = null;
        int k;
        int escolha;

        try{
             BufferedReader is = new BufferedReader(new InputStreamReader(System.in));
             Scanner scan = new Scanner (System.in);
             k=0;
             while(true){
                System.out.println("Deseja adicionar um aluno (s/n): ");
                inputLine = is.readLine();
                if(inputLine.equals("n")) break;

                System.out.println("Digite o nome do aluno: ");
                inputLine = is.readLine();
                do{
                    System.out.println("Escolha a faculdade do aluno (1-ITA, 2-USP, 3-Unicamp): ");
                    escolha=scan.nextInt();
                }while(escolha>3 || escolha<1);
                if(escolha==1){
                    alunosTeste[k]=new AlunoITA(inputLine,queue);
                }
                else if(escolha==2){
                    alunosTeste[k]=new AlunoUSP(inputLine,queue);
                }
                else{
                    alunosTeste[k]=new AlunoUnicamp(inputLine,queue);
                }
                do{
                    System.out.println("Escolha o tipo do aluno (1-Summa, 2-Safo, 3-Esforcado, 4-Pemba, 5-Imprevisivel, 6-Burro): ");
                    escolha=scan.nextInt();
                }while(escolha>6 || escolha<1);
                try{
                    if(escolha==1) alunosTeste[k].setComportamento(new Summa(alunosTeste[k]));
                    else if(escolha==2) alunosTeste[k].setComportamento(new SafoPreguicoso(alunosTeste[k]));
                    else if(escolha==3) alunosTeste[k].setComportamento(new Esforcado(alunosTeste[k]));
                    else if(escolha==4) alunosTeste[k].setComportamento(new Pemba(alunosTeste[k]));
                    else if(escolha==5) alunosTeste[k].setComportamento(new Imprevisivel(alunosTeste[k]));
                    else                alunosTeste[k].setComportamento(new Burro(alunosTeste[k]));
                }
                catch(Exception e){
                    System.out.println("Criação não permitida.\nException "+e);
                    continue;
                }
                alunosTeste[k].fazEEntregaRelatorio();
                k++;
             }
        }
         catch(IOException e){
             System.out.println("IOException"+e);
             return;
        }
        professor.corrigirRelatorios();
    }
}

Resultados da criação de alunos através da classe Simulador:

resultadosimulador.JPG

Resultados da classe de testes:

resultadotestes.JPG

Conclusão

Neste laboratório, ainda foram encontradas algumas dificuldades com a sintaxe do Java. Por exemplo, na classe Simulador(), para pedir informações sobre o aluno ao usuário e na classe genérica Queue<T> na criação do array.
Com relação ao projeto, não houve grandes problemas, pois foi uma continuação do laboratório passado e todos já possuiam uma boa idéia de como as classes se organizavam.

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