Lab2 Francisco Germano

aluno: Francisco Germano Batista da Silva Júnior
ano/sem: 2008/2o.
data do laboratório (num. da semana) : 04/09/2008 (6)

Introdução

Nesse laboratório aprimorou-se a aplicação criada no primeiro laboratório. Os alunos passaram a ter comportamentos (Esforçado, Suma, Pemba, Burro, Safo, Imprevisível) e pertecerem a uma instituição de ensino superior (ITA, USP e Unicamp). Também foram criadas mensagens de erro quando um aluno de uma universidade tivessem um comportamento inadequado (comportamento de Suma para alunos da USP por exemplo). Por fim melhorou-se a classe de fila de relatórios para que ela fosse uma subclasse de uma clase fila de objetos genéricos.

Desenvolvimento

Foram implementadas 17 classes elas serão descritas a seguir:

Classe Aluno

Classe que define os alunos que farão os relatorios a ser entregues. Todo aluno será criado com o comportamento padrão esforçado e esse poderá ser modificado pelo método "setComportamento". A classe também possui métodos para obtermos informações do aluno (inteligência, dedicação) e para mandar o aluno fazer um relatório.

public class Aluno {
    // instance variables
 
    private int conhecimento;
    protected String nome;
    public RelaQueue queue;
    public Comportamento comportamento;
 
    public Aluno(String nome, RelaQueue queue) {
        this.nome = nome;
        this.queue = queue;
        this.comportamento = new Esforcado(this);
        this.conhecimento = 0;
    }
 
    /**
     * fazEEntregaRelatorio cria um relatorio, o coloca na fila de entrega e aumenta o conhecimento do aluno.
     * getConhecimento retorna o conhecimento do aluno
     * getInteligencia retorna a inteligencia do aluno
     * getDedicacao retorna a dedicação do aluno
     * getNome retorna o nome do aluno
     */
    public void fazEEntregaRelatorio() {
        double qualidade = (2 * this.comportamento.getDedicacao() + 1 * this.comportamento.getInteligencia())/3;
        double originalidade = (1 * this.comportamento.getDedicacao() + 2 * this.comportamento.getInteligencia()) / 3;
        Relatorio rela = new Relatorio(qualidade, originalidade, this);
        conhecimento++;
        queue.queue(rela);
    }
 
    public int getConhecimento() {
        return conhecimento;
    }
 
    public String getNome() {
        return nome;
    }
 
    public double getDedicacao() {
        return this.comportamento.getDedicacao();
    }
 
    public double getInteligencia() {
        return this.comportamento.getInteligencia();
    }
 
    public void setComportamento(Comportamento comportamento) throws Exception {
        this.comportamento = comportamento;
    }
}

Classe AlunoITA

Classe que representa os alunos do ITA. Existe um tratamento de exceção no método "setComportamento" que garante que os alunos do ITA não podem ter o comportamento "Burro".

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

Classe AlunoUSP

Classe que representa os alunos da USP. Existe um tratamento de exceção no método "setComportamento" que garante que os alunos do USP não podem ter o comportamento "Suma" e "SafoPreguicoso".

public class AlunoUSP extends Aluno {
 
    public AlunoUSP(String nome, RelaQueue queue) {
        super(nome, queue);
    }
 
    @Override
    public void setComportamento(Comportamento comportamento) throws Exception {
        if(comportamento instanceof Summa)
            throw new Exception();
        else if(comportamento instanceof SafoPreguicoso)
            throw new Exception();
        super.setComportamento(comportamento);
    }
}

Classe AlunoUnicamp

Classe que representa os alunos da Unicamp. Existe um tratamento de exceção no método "setComportamento" que garante que os alunos do Unicamp não podem ter o comportamento "Suma" e "SafoPreguicoso".

public class AlunoUnicamp extends Aluno {
    public AlunoUnicamp(String nome, RelaQueue queue) {
        super(nome, queue);
    }
 
    @Override
    public void setComportamento(Comportamento comportamento) throws Exception {
        if(comportamento instanceof Summa)
            throw new Exception();
        else if(comportamento instanceof SafoPreguicoso)
            throw new Exception();
        super.setComportamento(comportamento);
    }
}

Classe Comportamento

A classe "Comportamento" é uma classe abstrata que serve para representar o nível de dedicação e inteligência dos alunos. Ela implementa dois métodos abstratos "getDedicacao" e "getInteligencia".

public abstract class Comportamento {
 
    protected double inteligencia;
    protected double dedicacao;
    protected Aluno aluno;
 
    public abstract double getDedicacao();
 
    public abstract double getInteligencia();
}

Classe Burro

Essa sub-classe de "Comportamento" representa o comportamento de uma pessoa burra, por isso ela possui inteligência=0 e dedicacao=0.

public class Burro extends Comportamento{
 
    public Burro(Aluno al) {
        this.dedicacao=0;
        this.inteligencia=0;
        this.aluno=al;
    }
 
    @Override
    public double getDedicacao() {
        return dedicacao;
    }
 
    @Override
    public double getInteligencia() {
        return inteligencia;
    }

Classe Esforcado

Essa sub-classe de "Comportamento" representa o comportamento de uma pessoa esforcada, por isso ela possui dedicacao=1 inteligência=0.5 (mediana).

public class Esforcado extends Comportamento {
 
    public Esforcado(Aluno al) {
        this.dedicacao = 1;
        this.inteligencia = 0.5;
        this.aluno = al;
    }
 
    @Override
    public double getDedicacao() {
        return dedicacao;
    }
 
    @Override
    public double getInteligencia() {
        return inteligencia;
    }
}

Classe Imprevisivel

Essa sub-classe de "Comportamento" representa o comportamento de uma pessoa imprevisivel, por isso ela possui dedicacao e inteligência randomicas entre 0 e 1 (toda vez que essas variáveis forem retornadas pelos métodos getDedicacao e getInteligencia será com um valor diferente).

public class Imprevisivel extends Comportamento {
 
    public Imprevisivel(Aluno al) {
        this.aluno=al;
    }
 
    @Override
    public double getDedicacao() {
        Random random=new Random();
        this.dedicacao=random.nextDouble();
        return dedicacao;
    }
 
    @Override
    public double getInteligencia() {
        Random random=new Random();
        this.inteligencia=random.nextDouble();
        return inteligencia;
    }
 
}

Classe Pemba

Essa sub-classe de "Comportamento" representa o comportamento de uma pessoa pemba, por isso ela possui dedicacao e inteligência randomicas entre 0 e 0.5 (toda vez que essas variáveis forem retornadas pelos métodos getDedicacao e getInteligencia será com um valor diferente).

public class Pemba extends Comportamento {
 
    public Pemba(Aluno al) {
        this.aluno=al;
    }
 
    @Override
    public double getDedicacao() {
        Random random =new Random();
        this.dedicacao = random.nextDouble()/2;
        return dedicacao;
    }
 
    @Override
    public double getInteligencia() {
        Random random =new Random();
        this.inteligencia=random.nextDouble()/2;
        return inteligencia;
    }
 
}

Classe SafoPreguicoso

Essa sub-classe de "Comportamento" representa o comportamento de uma pessoa safa e preguicosa, por isso ela possui dedicacao randomica entre 0 e 0.5 (toda vez que essa variável for retornada pelo método getDedicacao será com um valor diferente, representando o carater preguiçoso do aluno) e inteligencia=1 (representando o carater safo do aluno).

public class SafoPreguicoso extends Comportamento {
 
    public SafoPreguicoso(Aluno al) {
        this.inteligencia=1;
        this.aluno=al;
    }
 
    @Override
    public double getDedicacao() {
        Random random=new Random();
        this.dedicacao=random.nextDouble()/2;
        return dedicacao;
    }
 
    @Override
    public double getInteligencia() {
        return inteligencia;
    }
 
}

Classe Summa

Essa sub-classe de "Comportamento" representa o comportamento de uma pessoa que será Summa Cum Laude, por isso ela possui dedicacao=1 e inteligência=1.

public class Summa extends Comportamento{
 
    public Summa(Aluno al){
        this.inteligencia=1;
        this.dedicacao=1;
        this.aluno=al;
    }
 
    @Override
    public double getDedicacao() {
        return dedicacao;
    }
 
    @Override
    public double getInteligencia() {
        return inteligencia;
    }
}

Classe Professor

Classe que representa os professores que corrigem os relatórios.

public class Professor
{
    // instance variables
    RelaQueue queue;
    /**
     * Constructor for objects of class Professor
     */
    public Professor(RelaQueue fila)
    {
        this.queue=fila;
    }
 
    /**
     * corrigirRelatorio corrige um relatorio, o retira da fila e retorna a sua nota
     * corrigirRelatorios corrige todos os relatorios da fila e apresenta suas notas na tela
     */
    private double corrigirRelatorio(Relatorio rela){
        Random qualquer=new Random();
        double nota = ( rela.getQualidade() + rela.getOriginalidade() + qualquer.nextFloat()) / 3 * 10;
        return nota;
    }
    public void corrigirRelatorios(){
        Relatorio temp=queue.dequeue();
        while(temp!=null){
            System.out.println(temp.getAluno().getNome()+ ": " +this.corrigirRelatorio(temp));
            temp=queue.dequeue();
        }
    }
}

Classe Relatorio

Classe que representa os relatorios feitos pelos alunos

public class Relatorio
{
    // instance variables
    private double qualidade;
    private double originalidade;
    private Aluno aluno;
 
    /**
     * Constructor for objects of class Relatorio
     */
    public Relatorio(double qld, double ori, Aluno al)
    {
        this.qualidade=qld;
        this.originalidade=ori;
        this.aluno=al;
    }
 
    /**
     * getAluno retorna o aluno que fez o relatorio
     * getQualidade retorna a qualidade do relatorio
     * getOriginalidade retorna a originalidade do relatorio
     */
 
    public double getQualidade(){
        return qualidade;}
    public double getOriginalidade(){
        return originalidade;}
    public Aluno getAluno(){
        return aluno;}
}

Classe Queue

Classe que representa uma fila de objetos instâncias da classe T. Como a fila é uma fila de objetos genéricos ela é muito mais flexível e útil que a classe RelaQueue implementada no laboratório anterior.

public class Queue<T> {
// instance variables
 
    private Vector<T> array = new Vector<T>();
 
    /**
    Metódo queue coloca um objeto na fila.
    Método dequeue retira um objeto da fila (caso exista algum elemento na fila).
     */
    public void queue(T obj) {
        array.add(obj);
    }
 
    public T dequeue() {
        if (array.size() == 0) {
            return null;
        } else {
            T obj = (T)array.remove(0);
            return obj;
        }
    }
}

Classe RelaQueue

A classe RelaQueue extende a classe Queue especificando que será uma fila de objetos do tipo "Relatorio".

public class RelaQueue extends Queue<Relatorio> {
}

Classe SimuladorInicial

public class SimuladorInicial {
 
    public static void main(String[] args) {
        int c = 0, n, i, j, erro = 0;
        Vector vetAluno = new Vector();
        RelaQueue fila = new RelaQueue();
        Scanner scan = new Scanner(System.in);
        Aluno al;
        //Comportamento comp;
        Professor professor = new Professor(fila);
 
        while (c != 4) {
            System.out.println("1 - Adicionar aluno");
            System.out.println("2 - Fazer relatório");
            System.out.println("3 - Corrigir relatórios");
            System.out.println("4 - Sair");
 
            do {
                c = scan.nextInt();
            } while (c < 1 || c > 4);
 
            switch (c) {
 
                case 1:
                    System.out.println("\nDigite o numero de alunos que serão inseridos");
                    n = scan.nextInt();
 
                    for (i = 0; i < n; i++) {
                        System.out.print("\nDigite o nome do aluno ");
                        System.out.println(i + 1);
                        String str = new String();
                        scan.useDelimiter("\n");
                        str = scan.next();
                        System.out.println("\nDigite o tipo de aluno\n1 - Esforcado\n2 - Safo Preguicoso");
 
                        do {
                            j = scan.nextInt();
                        } while (j < 1 || j > 2);
 
                        switch (j) {
                            case 1:
                                al = new AlunoEsforcado(str, fila);
                                break;
                            default:
                                al = new AlunoSafoPreguicoso(str, fila);
                        }
 
                        vetAluno.add(al);
                    }
                    break;
 
                case 2:
                    System.out.println("\nQual aluno deve fazer o relatorio?");
 
                    for (i = 0; i < vetAluno.size(); i++) {
                        al = (Aluno) vetAluno.get(i);
                        System.out.print(i + 1);
                        System.out.println(" - " + al.getNome());
                    }
 
                    n = scan.nextInt();
                    al = (Aluno) vetAluno.get(n - 1);
                    al.fazEEntregaRelatorio();
                    break;
 
                case 3:
                    professor.corrigirRelatorios();
 
            }
            System.out.println("\n");
 
        }
 
    }
 
}

Classe Simulador

A classe SimuladorInicial cria uma interface na qual o usúario pode inserir alunos, mandar os alunos inseridos fazerem relatórios e mandar o professor corrigir os relatórios. Ao solicitar a inserção de um aluno as novas disponibilidades do segundo laboratório estão disponíveis (comportamentos para os alunos e instituições de ensino distintas). As excessões previstas nas classes AlunoITA, AlunoUSP e AlunoUnicamp foram devidamente tratadas e mensagens de erro aparecerão para o usuario caso ele resolva criar um aluno de um tipo proibido.

public class Simulador {
 
    public static void main(String[] args) {
        int c = 0, n, i, j, erro = 0;
        Vector vetAluno = new Vector();
        RelaQueue fila = new RelaQueue();
        Scanner scan = new Scanner(System.in);
        Aluno al;
        Comportamento comp;
        Professor professor = new Professor(fila);
 
        while (c != 4) {
            System.out.println("1 - Adicionar aluno");
            System.out.println("2 - Fazer relatório");
            System.out.println("3 - Corrigir relatórios");
            System.out.println("4 - Sair");
 
            do {
                c = scan.nextInt();
            } while (c < 1 || c > 4);
 
            switch (c) {
 
                case 1:
                    System.out.println("\nDigite o numero de alunos que serão inseridos");
                    n = scan.nextInt();
 
                    for (i = 0; i < n; i++) {
                        System.out.print("Digite o nome do aluno ");
                        System.out.println(i + 1);
                        String str = new String();
                        scan.useDelimiter("\n");
                        str = scan.next();
                        System.out.println("Digite a instituicao do aluno\n1 - ITA\n2 - USP\n3 - Unicamp\n");
 
                        do {
                            j = scan.nextInt();
                        } while (j < 1 || j > 3);
 
                        switch (j) {
                            case 1:
                                al = new AlunoITA(str, fila);
                                break;
                            case 2:
                                al = new AlunoUSP(str, fila);
                                break;
                            default:
                                al = new AlunoUnicamp(str, fila);
                        }
                        do {
                            System.out.print("Digite o comportamento do aluno\n1 - Esforcado\n2 - Safo Preguicoso\n");
                            System.out.println("3 - Pemba\n4 - Suma\n5 - Burro\n6 - Imprevisivel\n");
 
                            do {
                                j = scan.nextInt();
                            } while (j < 1 || j > 6);
 
                            switch (j) {
                                case 1:
                                    comp = new Esforcado(al);
                                    try {
                                        al.setComportamento(comp);
                                        erro = 0;
                                    } catch (Exception e) {
                                        erro = 1;
                                    }
                                    break;
                                case 2:
                                    comp = new SafoPreguicoso(al);
                                    try {
                                        al.setComportamento(comp);
                                        erro = 0;
                                    } catch (Exception ex) {
                                        System.out.println("Somente alunos do ITA podem ser safos preguicosos\n");
                                        erro = 1;
                                    }
                                    break;
                                case 3:
                                    comp = new Pemba(al);
                                    try {
                                        al.setComportamento(comp);
                                        erro = 0;
                                    } catch (Exception ex) {
                                        erro = 1;
                                    }
                                    break;
                                case 4:
                                    comp = new Summa(al);
                                    try {
                                        al.setComportamento(comp);
                                        erro = 0;
                                    } catch (Exception ex) {
                                        System.out.println("Somente alunos do ITA podem ser Suma\n");
                                        erro = 1;
                                    }
                                    break;
                                case 5:
                                    comp = new Burro(al);
                                    try {
                                        al.setComportamento(comp);
                                        erro = 0;
                                    } catch (Exception ex) {
                                        System.out.println("Alunos do ITA não podem ser burros\n");
                                        erro = 1;
                                    }
                                    break;
                                case 6:
                                    comp = new Imprevisivel(al);
                                    try {
                                        al.setComportamento(comp);
                                        erro = 0;
                                    } catch (Exception ex) {
                                        erro = 1;
                                    }
                            }
                        } while (erro == 1);
 
                        vetAluno.add(al);
                    }
                    break;
 
                case 2:
                    System.out.println("Qual aluno deve fazer o relatorio?");
 
                    for (i = 0; i < vetAluno.size(); i++) {
                        al = (Aluno) vetAluno.get(i);
                        System.out.print(i + 1);
                        System.out.println(" - " + al.getNome());
                    }
 
                    n = scan.nextInt();
                    al = (Aluno) vetAluno.get(n - 1);
                    al.fazEEntregaRelatorio();
                    break;
 
                case 3:
                    professor.corrigirRelatorios();
            }
            System.out.println("\n");
        }
    }
}

O diagrama de classe final do projeto é o seguinte:
ClassDiagram.jpg

Os testes rodados tiveram um resultado satisfatório como apresentado na seguinte imagem:
TestTerminal.jpg

Anexe o arquivo com código nesta página.

Conclusão

Podemos destacar como pontos fortes do laboratório o tratamento de excessões e a nova estruturação de classes (utilizando comportamentos separados das subclasses de alunos). Como sugestão para melhorar a aplicação poderiamos criar distinção de cursos para cada universidade (como uma classe a parte da mesma forma que comportamento) e a correção dos relatorios por cada professor deveria levar em consideração o curso (alguns cursos tem maior cobrança que outros).

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