Lab2 Douglas Bokliang

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

Introdução

Neste segundo laboratório modificamos o laboratório anterior a fim de implementar um programa mais complexo. Criamos três subclasses da classe Aluno (que deixou de ser abstrata), que identifica em que instituição o aluno estuda (ITA, Unicamp ou USP). Além disso, criamos uma classe abstrata Comportamento (que foi o que possibilitou que a classe Aluno deixasse de ser abstrata) que define o comportamento de aluno: summa, safo-preguiçoso, esforçado, imprevisível, pemba e burro. No entanto, foi necessário utilizar tratamento de exceções para impedir que determinados comportamentos fossem atribuídos a determinados alunos.
Uma grande diferença desse laboratório em relação ao anterior foi a criação de uma classe Simulador, a qual possui um método main que interage com o usuário.

Desenvolvimento

Muitas das classes feitas no laboratório anterior puderam ser reaproveitadas nesse último. Algumas necessitaram apenas de algumas modificações, como será visto a seguir.

Classe Aluno
Classe que possui três subclasses: AlunoITA, AlunoUnicamp e AlunoUSP. Cada uma dessas sobrescreve o método setComportamento de uma forma através do Exception().
Manda os alunos fazerem seus relatórios, deixando-os numa fila para mais tarde serem corrigidos pelo professor.

public class Aluno {
    private int conhecimento = 0;
    private String nome;
    private RelaQueue queue;
    private Comportamento comportamento;
 
    //constructor
    public Aluno (String nome, RelaQueue queue) {
        this.nome = nome;
        this.queue = queue;
        comportamento = new Esforcado(this);
    }
 
    //metodo que calcula a qualidade e a originalidade do relatorio e usa esses parametros para
    //criar um relatorio
    public void fazEEntregaRelatorio () {   
        double qualidade = (2 * this.getDedicacao() + 1 * this.getInteligencia() ) / 3 ;
        double originalidade = (1 * this.getDedicacao() + 2 * this.getInteligencia() ) / 3 ;
 
        Relatorio rela = new Relatorio(qualidade, originalidade, this);
 
        queue.queue(rela);
        conhecimento++;
    }
 
    //getters
    public int getConhecimento (){
        return conhecimento;
    }
 
    public String getNome () {
        return nome;
    }
 
    public double getDedicacao () {
        return comportamento.getDedicacao();
    }
 
    public double getInteligencia () {
        return comportamento.getInteligencia();
    }
 
    //setter
    public void setComportamento (Comportamento comportamento) throws Exception {
        this.comportamento = comportamento;
    }
}

Classe AlunoITA
Esta subclasse de Aluno impede que o comportamento Burro seja atribuído a um objeto dessa classe.

public class AlunoITA extends Aluno {
 
    //constructor
    public AlunoITA (String nome, RelaQueue queue) {
        super(nome,queue);
    }
 
    @Override //nao pode ser burro
    public void setComportamento (Comportamento comportamento) throws Exception {
        if(comportamento instanceof Burro) throw new Exception();
        super.setComportamento(comportamento);
    }
}

Classe AlunoUnicamp
Esta subclasse de Aluno impede que o comportamento Safo-Preguiçoso e Summa seja atribuído a um objeto dessa classe.

public class AlunoUnicamp extends Aluno{
    //constructor
    public AlunoUnicamp (String nome, RelaQueue queue) {
        super(nome,queue);
    }
 
    @Override //nao pode ser summa nem safo preguicoso
    public void setComportamento (Comportamento comportamento) throws Exception {
        if(comportamento instanceof Summa) throw new Exception();
        if(comportamento instanceof SafoPreguicoso) throw new Exception();
        super.setComportamento(comportamento);
    }
}

Classe AlunoUSP
Esta subclasse de Aluno impede que o comportamento Safo-Preguiçoso e Summa seja atribuído a um objeto dessa classe.

public class AlunoUSP extends Aluno{
    //constructor
    public AlunoUSP (String nome, RelaQueue queue) {
        super(nome,queue);
    }
 
    @Override //nao pode ser summa nem safo preguicoso
    public void setComportamento (Comportamento comportamento) throws Exception {
        if(comportamento instanceof Summa) throw new Exception();
        if(comportamento instanceof SafoPreguicoso) throw new Exception();
        super.setComportamento(comportamento);
    }
}

Classe Comportamento
Esta classe é abstrata. Possui dois métodos abstratos: getInteligencia e getDedicacao. Cada um deles é definido pelo respectivo comportamento (summa, safo-preguiçoso, esforçado, imprevisível, pemba ou burro) a qual pertence o objeto.

public abstract class Comportamento {
    private Aluno aluno;
 
    //constructor
    public Comportamento (Aluno aluno) {
        this.aluno = aluno;
    }
 
    //metodos abstratos
    public abstract double getInteligencia ();
 
    public abstract double getDedicacao ();
}

Classe Summa
Determina o comportamento de um aluno summa.

public class Summa extends Comportamento {
 
    public Summa (Aluno aluno) {
        super(aluno);         //aproveita o constructor de Comportamento
    }
 
    //metodos especificos da subclasse
    public double getInteligencia () {
        return 1.;
    }
 
    public double getDedicacao () {
        return 1.;
    }    
}

Classe SafoPreguiçoso
Determina o comportamento de um aluno safo-preguiçoso

public class SafoPreguicoso extends Comportamento {
 
    public SafoPreguicoso (Aluno aluno) {
        super(aluno);         //aproveita o constructor de Comportamento
    }
 
    //metodos especificos da subclasse
    public double getInteligencia () {
        return 1.;
    }
 
    public double getDedicacao () {
        return .5*Math.random();
    }    
}

Classe Esforçado
Determina o comportamento de um aluno esforçado.

public class Esforcado extends Comportamento{
    //constructor
    public Esforcado (Aluno aluno) {
        super(aluno);         //aproveita o constructor de Comportamento
    }
 
    //getters
    public double getInteligencia () {
        return .5;
    }
 
    public double getDedicacao () {
        return 1.;
    }
}

Classe Imprevisível
Determina um comportamento aleatório.

public class Imprevisivel extends Comportamento {
 
    public Imprevisivel (Aluno aluno) {
        super(aluno);         //aproveita o constructor de Comportamento
    }
 
    //metodos especificos da subclasse
    public double getInteligencia () {
        return Math.random();
    }
 
    public double getDedicacao () {
        return Math.random();
    }    
}

Classe Pemba
Determina o comportamento de um aluno pemba.

public class Pemba extends Comportamento {
 
    public Pemba (Aluno aluno) {
        super(aluno);         //aproveita o constructor de Comportamento
    }
 
    //metodos especificos da subclasse
    public double getInteligencia () {
        return .5*Math.random();
    }
 
    public double getDedicacao () {
        return .5*Math.random();
    }    
}

Classe Burro
Determina o comportamento de um aluno burro.

public class Burro extends Comportamento {
 
    public Burro (Aluno aluno) {
        super(aluno);         //aproveita o constructor de Comportamento
    }
 
    //metodos especificos da subclasse
    public double getInteligencia () {
        return 0.;
    }
 
    public double getDedicacao () {
        return 0.;
    }    
}

Classe Professor
Corrige todos os relatórios deixados numa fila pelos alunos.

public class Professor {
    private RelaQueue queue;
 
    //constructor
    public Professor (RelaQueue queue) {
        this.queue = queue;
    }
 
    //metodo privado, retorna a nota do relatorio
    private double corrigirRelatorio (Relatorio rela) {
        double fatorAleatorioDe0a1 = Math.random();
        return ( rela.getQualidade() + rela.getOriginalidade() + fatorAleatorioDe0a1 ) / 3 * 10;   
    }
 
    //tira sempre o primeiro relatorio da fila e chama o metodo anterior para obter a nota
    //faz isso ateh acabarem todos os relatorios da fila
    public void corrigirRelatorios () {
        Relatorio rela = queue.dequeue();
 
        while (rela != null) {
            double nota = this.corrigirRelatorio (rela);  
            System.out.println (rela.getAluno().getNome() + ": " + nota); 
            rela = queue.dequeue();
        }
    }
}

Classe Lab2Test
Classe que verifica se todas as classes e métodos estão como o previsto a priori. Código igual ao fornecido na instrução.

Classe Queue
Classe que monta uma fila de um tipo genérico.

public class Queue<T> {    
    private Object[] array  = new Object[10];  //usando a classe Objeto 
    private int inicio, fim;  
 
    public void queue(T obj) {   
        array[fim] = obj;
        fim = (fim + 1) % 10;
    }   
 
    public T dequeue(){   
        if (inicio == fim) return null;
 
        T valor = (T)array[inicio];
        inicio = (inicio + 1) % 10;
 
        return valor;    
    }   
}

Classe RelaQueue
Subclasse de Queue. Uma fila de objetos do tipo Relatório.

public class RelaQueue extends Queue<Relatorio> {
}

Classe Relatório
Possui os valores de qualidade e originalidade do relatório de um referido aluno, que são mais tarde utilizados pelo Professor para dar as notas de cada um.

public class Relatorio {
    private double qualidade;
    private double originalidade;
    private Aluno aluno;
 
    //constructor
    public Relatorio (double qualidade, double originalidade, Aluno aluno) {
        this.aluno = aluno;
        this.originalidade = originalidade;
        this.qualidade = qualidade;
    }
 
    //getters
    public Aluno getAluno() {
        return aluno;
    }
 
    public double getOriginalidade() {
        return originalidade;
    }
 
    public double getQualidade() {
       return qualidade;
    }
 
    //setter
    public void setAluno(Aluno aluno) {
        this.aluno = aluno;
    }
}

Classe Simulador
Classe que possui o método main. Interage com o usuário perguntando quantos alunos serão criados e suas respectivas características.

import java.io.BufferedReader;  
import java.io.IOException;  
import java.io.InputStreamReader;
 
public class Simulador {
    //inicializando a fila de relatorios
    static RelaQueue relaqueue = new RelaQueue();
 
    //metodo principal
    public static void main (String[] args) throws IOException {
        //lendo o numero de alunos
        System.out.println("Digite o número de alunos: ");        
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        int n_alunos = Integer.parseInt(reader.readLine());
 
        //para cada aluno, pegar as informacoes dele e manda-lo fazer o relatorio
        for(int i = 0; i < n_alunos; i++) {
            //nome
            System.out.println("Digite o nome do aluno " +(i+1) );
            reader = new BufferedReader(new InputStreamReader(System.in));
            String nome = reader.readLine();
            System.out.println("");
 
            //universidade onde estuda
            System.out.println("Onde este aluno estuda?");
            System.out.println("1 - ITA");
            System.out.println("2 - Unicamp");
            System.out.println("3 - USP");
 
            int universidade;
            do{
                reader = new BufferedReader(new InputStreamReader(System.in));
                universidade = Integer.parseInt(reader.readLine());
            } while(universidade < 1 || universidade > 3);
            System.out.println("");
 
            Aluno aluno;
            if(universidade == 1)
                aluno = new AlunoITA(nome, relaqueue);
            else if (universidade == 2) 
                aluno = new AlunoUnicamp(nome, relaqueue);
            else
                aluno = new AlunoUSP(nome, relaqueue);        
 
            //verificando o comportamento
            System.out.println("Qual o comportamento desse aluno?");
            System.out.println("1 - Summa");
            System.out.println("2 - SafoPreguiçoso");
            System.out.println("3 - Esforçado");
            System.out.println("4 - Imprevisível");
            System.out.println("5 - Pemba");
            System.out.println("6 - Burro");
 
            //ligando o aluno ao comportamento, verificando se eh possivel
            //se nao, pedir outro comportamento
            Comportamento comportamento;
            int exception;
            do{ 
                exception = 0; //utilizado para verificar se alguma excessao foi utilizada
                int comp;
                do{
                    reader = new BufferedReader(new InputStreamReader(System.in));
                    comp = Integer.parseInt(reader.readLine());
                } while(comp < 1 || comp > 6);
                System.out.println("");
 
                if (comp == 1) {
                    try{
                        comportamento = new Summa(aluno);
                        aluno.setComportamento(comportamento);
                    }
                    catch (Exception e){
                        System.out.println("Você tentou fazer algo impossível!");
                        System.out.println("Agora digite o comportamento VERDADEIRO!!");
                        exception = 1;
                    }
                } else if (comp == 2) {
                    try{
                        comportamento = new SafoPreguicoso(aluno);
                        aluno.setComportamento(comportamento);
                    }
                    catch (Exception e){
                        System.out.println("Você tentou fazer algo impossível!");
                        System.out.println("Agora digite o comportamento VERDADEIRO!!");
                        exception = 1;
                    }
                } else if (comp == 3) {
                    try{
                        comportamento = new Esforcado(aluno);
                        aluno.setComportamento(comportamento);
                    }
                    catch (Exception e){
                        System.out.println("Você tentou fazer algo impossível!");
                        System.out.println("Agora digite o comportamento VERDADEIRO!!");
                        exception = 1;
                    }
                } else if (comp == 4) {
                    try{
                        comportamento = new Imprevisivel(aluno);
                        aluno.setComportamento(comportamento);
                    }
                    catch (Exception e){
                        System.out.println("Você tentou fazer algo impossível!");
                        System.out.println("Agora digite o comportamento VERDADEIRO!!");
                        exception = 1;
                    }
                } else if (comp == 5) {
                    try{
                        comportamento = new Pemba(aluno);
                        aluno.setComportamento(comportamento);
                    }
                    catch (Exception e){
                        System.out.println("Você tentou fazer algo impossível!");
                        System.out.println("Agora digite o comportamento VERDADEIRO!!");
                        exception = 1;
                    }
                } else {
                    try{
                        comportamento = new Burro(aluno);
                        aluno.setComportamento(comportamento);
                    }
                    catch (Exception e){
                        System.out.println("Você tentou fazer algo impossível!");
                        System.out.println("Agora digite o comportamento VERDADEIRO!!");
                        exception = 1;
                    }
                }
            } while (exception == 1);
            aluno.fazEEntregaRelatorio(); //manda o aluno fazer e entegar os relatorios
        }
        //criando o professor e mandando ele corrigir os relatorios
        Professor professor = new Professor(relaqueue);
        professor.corrigirRelatorios();
    }
}

RESULTADOS
Criou-se diversos alunos, cada um com diferentes características, para testar a funcionalidade do programa. Tentou-se criar alunos com comportamentos incompatíveis com sua instituição para testar o tratamento de excessões.

figura1.jpg
figura2.jpg

Conclusão

Pode-se dizer que este laboratório foi razoavelmente mais exigente que o primeiro. Foi necessário aprender a utilizar alguns conceitos novos: tratamento de exceções, classe de tipo genérico e implementação do main.
Na criação do método main, dentro da classe Simulador, foi necessário aprender diversos comandos novos. Considerei um grande trabalho fazer a parte de interação com o usuário.

lab2

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