relas:lab2_Pedro_Cau

aluno: Pedro de Sousa Cau Ramos Salles
2008/2o.
07/09/2008

Introdução

Este laboratorio foi uma continuação do laboratorio 1, adicionando novas funcionalidades. A funcionalidades adicionadas foram:
-Interface com o usuario, permitindo criação manual dos alunos e ordem de entrega e correção de relas, via linha de comando;
-Novos tipos de comportamento, alem dos dois originais foram adicionados: Summa, Pemba,Imprevisivel e Burro. Passando agora
a serem subclassses de Comportamento ao invez de aluno, permitindo aluno mudar de comportamento.
-Alunos podem pertencer a uma instituição especifica, que influi nas possibilidades de comportamento do aluno.
-RelaQueue passa a ser uma subclasse de uma Queue generica aplicada a relatorios.

Desenvolvimento

Nessa primeira parte foi criada uma classe Simulação, que permite um usuário a criar alunos e ordenar entregas de relas e correções pelo professor, via linha de comando. A outras classes foram inalteradas em relação ao Lab 1. O código da classe Simulação está a seguir:

import java.util.Scanner;
 
public class Simulador
{
    private static RelaQueue queue = new RelaQueue();
    private static Aluno[] Alunos= new Aluno[30];
    private static int numAlunos = 0;
    private static Professor teacher = new Professor(queue);
 
    public static void main()
    {        
        System.out.println("Classe Simulador\n");
        boolean quit = false;
        while(!quit)
        {
            System.out.println("\n\n");
            Scanner scan = new Scanner(System.in);
 
            System.out.println("Escolha uma opcao:\n");
            System.out.println("1-Criar Novo Aluno"); 
            System.out.println("2-Entregar Relatorio");
            System.out.println("3-Corrigir Relatorios");
            System.out.println("4-Sair\n");
            System.out.print("Opção: ");
 
            String str = scan.next(); 
 
            while(!str.equals("1") && !str.equals("2") &&
                  !str.equals("3") && !str.equals("4"))
            {
                System.out.print("Opcao invalida, tente denovo.\nOpção: ");
                str = scan.next();
            }
            int opt = Integer.parseInt(str);
 
            System.out.print("\n\n");
            switch(opt)
            {
                case 1:
                criarAluno();
                break;
 
                case 2:
                fazerRelas();
                break;
 
                case 3:
                corrigirRelas();
                break;
 
                case 4:
                quit = true;
                break;
            }
        }     
    }   
    private static void criarAluno()
    {   
 
        Scanner scan = new Scanner(System.in);
 
        System.out.print("Nome do aluno: ");
        String str = scan.next();
        System.out.println("\nEscolha do tipo de aluno: \n");
        System.out.println("1 : Safo Preguiçoso");            
        System.out.println("2 : Esforçado \n");
        System.out.print("Opção: "); 
        String str2 = scan.next();
 
        while(!str2.equals("1") && !str2.equals("2"))
        {
            System.out.print("Opcao invalida, tente denovo.\nOpção: ");
            str2 = scan.next();
        }
        int opt = Integer.parseInt(str2);
 
        Aluno novoAluno = null;
 
        switch(opt)
        {
            case 1:
            novoAluno = new AlunoSafoPreguicoso(str,queue);
            break;
 
            case 2:
            novoAluno = new AlunoEsforcado(str,queue);
            break;
         }
         Alunos[numAlunos] = novoAluno;
         numAlunos++;
 
         System.out.println("Alunos criados: ");
         for(Aluno a : Alunos)
         {
             if(a!=null)System.out.println(a.getNome());
         }
    }
 
    private static void fazerRelas()
    {
         Scanner scan = new Scanner(System.in);
         System.out.println("De o nome do aluno a fazer o rela: ");
         String nome = scan.next();
         Aluno getAluno = null;
         for(Aluno a : Alunos)
         {
             if(a!=null)
             {
                 if(a.getNome().equals(nome))getAluno = a;
             }
         }
         if(getAluno==null)System.out.println("Aluno com nome "+nome+" nao existe, tente novamente.");
         else
         {
             getAluno.fazEEntregaRelatorio();
             System.out.println("Relatorio de "+nome+" entregue.");
         }
    }
 
    private static void corrigirRelas()
    {
         System.out.println("Relatorios corrigidos. Notas:");
         teacher.corrigirRelatorios();
    }
}

Ao executar o método main(), aparecerá o console:

Classe Simulador

Escolha uma opcao:

1-Criar Novo Aluno
2-Entregar Relatorio
3-Corrigir Relatorios
4-Sair

Opção:

Ao escolher a opção 1, criar um novo aluno, aparecerá :

Nome do aluno: Jose

Escolha do tipo de aluno:

1 : Safo Preguiçoso
2 : Esforçado

Opção: 1
Alunos criados:
Jose

Onde o usuário deverá fornecer o nome do novo aluno e o seu tipo, conforme mostrado acima.

Retornando à tela inicial e escolhendo a opção 2, pede-se para se escolher qual aluno entregará o rela :

De o nome do aluno a fazer o rela:
Jose
Relatorio de Jose entregue.

Por ultimo, escolhendo a opção 3, se ordenará que o professor corrija os relas:

Relatorios corrigidos. Notas:
Jose: 6.3218255

Na segunda parte, foi realizada a extenção do lab1, como foi descrito na introdução.

Temos o seguinte diagrama de classes no blueJ:

diagram.JPG

As classes do projeto estão descritas a seguir:

Classe Comportamento;

Esta classe define qual é o comportamento do aluno, tendo os metodos abstratos getInteligencia e getDedicação a serem delegadas pelo Aluno:

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

Classe Esforcado

Define o mesmo comportamento de AlunoEsforcado do Lab1

public class Esforcado extends Comportamento
{
        float inteligencia = 0.5f; //inteligencia definida menor que a do alunosafopreguicoso
        float dedicacao = 1.0f;     //dedicacao definida maior que a do alunosafopreguicoso
 
        public Esforcado(Aluno aluno)
        {
             super(aluno);
        }
 
        public float getInteligencia()
        {
            return inteligencia;
        }
 
        public float getDedicacao()
        {
            return dedicacao;
        }
}

Classe SafoPreguicoso

Define o mesmo comportamento de AlunoSafoPreguicoso do Lab1

public class SafoPreguicoso extends Comportamento
{
    float inteligencia = 1.0f; //inteligencia definida maior que o alunodedicado
 
    public SafoPreguicoso(Aluno aluno)
        {
             super(aluno);
        }   
 
    public float getInteligencia()
    {
        //O método getInteligencia de AlunoSafoPreguicoso deve retornar um double randômico de 0 a 0,5.
        return inteligencia;
    }
 
    public float getDedicacao()
    {
        //gerando um valor aleatorio para a dedicacao de 0 a 0.5
        return (float)Math.random()/ 2.0f;
    }
}

Classe Summa

Define um comportamento onde Inteligencia e Dedicação são sempre 1

public class Summa extends Comportamento
{
    public Summa(Aluno aluno)
    {
        super(aluno);
    }   
    public float getInteligencia()
    {
        //sempre 1
        return 1.0f;
    }
 
    public float getDedicacao()
    {
        //sempre 1
        return 1.0f;
    }
}

Classe Pemba

O comportamento e a dedicação são aleatorios de 0 a 0.5

public class Pemba extends Comportamento
{
    public Pemba(Aluno aluno)
    {
        super(aluno);
    }   
    public float getInteligencia()
    {
        //valor aleatorio para a inteligencia de 0 a 0.5
        return (float)Math.random()/ 2.0f;
    }
 
    public float getDedicacao()
    {
        //gerando um valor aleatorio para a dedicacao de 0 a 0.5
        return (float)Math.random()/ 2.0f;
    }
}

Classe Imprevisivel

O comportamento e a dedicação são aleatorios de 0 a 1

public class Imprevisivel extends Comportamento
{ 
    public Imprevisivel(Aluno aluno)
    {
         super(aluno);
    }   
    public float getInteligencia()
    {
        //gerando um valor aleatorio para a inteligencia de 0 a 1
        return (float)Math.random();
    }
 
    public float getDedicacao()
    {
        //gerando um valor aleatorio para a dedicacao de 0 a 1
        return (float)Math.random();
    }
}

Classe Burro

O comportamento e a dedicação são sempre 0

public class Burro extends Comportamento
{
    public Burro(Aluno aluno)
    {
        super(aluno);
    }   
    public float getInteligencia()
    {
        //sempre 0
        return 0.0f;
    }
 
    public float getDedicacao()
    {
        //sempre 0
        return 0.0f;
    }
}

Classe Aluno

Esta classe deixou de ser abstrata, e passou a delegar as chamas de getInteligencia e getDedicação para a classe Comportamento a ela associada; Quando o aluno é criado, seu comportamento é por padrão definido como Esforcado;

public class Aluno
    {
 
        int conhecimento = 0; //conhecimento adquirido fazendo relas
        String nome; //nome do aluno
        RelaQueue queue; // referencia para a fila de relas
        Comportamento meuComportamento = new Esforcado(this);
 
        public Aluno(String nome , RelaQueue queue)
        {  //inicializaçoes
            this.nome = nome; 
            this.queue = queue;
        }
 
        public void fazEEntregaRelatorio()
        {
            //equaçao que define as caracteristicas do rela baseado nas capacidades do aluno 
            float qualidade = (2.0f * this.getDedicacao() + 1.0f * this.getInteligencia()) / 3.0f;
            float originalidade = (1.0f * this.getDedicacao() + 2.0f * this.getInteligencia()) / 3.0f;
            //adicionando o rela na fila
            queue.queue(new Relatorio(qualidade,originalidade,this));
            //adquirindo conhecimento
            conhecimento++;
        }
 
        public void setComportamento(Comportamento novoComportamento)throws Exception 
        {
            meuComportamento = novoComportamento;
        }
 
        public int getConhecimento()
        {
            return conhecimento;
        }
 
        public float getInteligencia()
        {
            return meuComportamento.getInteligencia();
        };
 
        public float getDedicacao()
        {
            return meuComportamento.getDedicacao();
        };
 
        public String getNome()
        {
            return nome;
        }
    }

Classe AlunoITA

Esta subclasse de aluno impede que o aluno tenha comportamento burro, podendo causar um exception;

public class AlunoITA extends Aluno
{
    public AlunoITA(String nome , RelaQueue queue)
    {
        super(nome , queue);
    }
    public void setComportamento(Comportamento comportamento) throws Exception 
    {
        if(comportamento instanceof Burro) throw new Exception(); //iteanos não são burros!
        super.setComportamento(comportamento); //faz o que a superclasse Aluno faz.
    }
 
}

Classe AlunoUSP

Esta subclasse de aluno impede que o aluno tenha comportamento summa ou safopreguicoso, podendo causar um exception;

public class AlunoUSP extends Aluno
{
   public AlunoUSP(String nome , RelaQueue queue)
    {
        super(nome , queue);
    }
    public void setComportamento(Comportamento comportamento) throws Exception 
    {
        if(comportamento instanceof Summa || comportamento instanceof SafoPreguicoso) throw new Exception(); //iteanos não são burros!
        super.setComportamento(comportamento); //faz o que a superclasse Aluno faz.
    }
}

Classe AlunoUnicamp

O mesmo de AlunoUSP

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 || comportamento instanceof SafoPreguicoso) throw new Exception(); //iteanos não são burros!
        super.setComportamento(comportamento); //faz o que a superclasse Aluno faz.
    }
}

Classe Queue<Type>

O mesmo esqueleto de codigo do RelaQueue do Lab1, só que agora trabalhando com um tipo generico Type

public class Queue<Type>
{
    private Type[] lista = (Type[])new Object[10];//vetor de relatorios
        int inicio = 0; //cursor do inicio da fila
        int fim = 0; //cursor do final da fila
 
    public void queue(Type item)
    {
        lista[fim] = item; // salva o rela no vetor
        fim = (fim + 1) % 10; //incrementa o fim da fila com loop sobre o vetor
    }
 
    public Type dequeue()
    {
        if (fim != inicio) //se houver algum rela na fila
        {
            Type dequeued = lista[inicio];
            inicio = (inicio + 1) % 10; //retira um rela do inicio da fila
            return dequeued; // e retorna
        }
        else return null; // se nao tem rela, vai null
    }
}

Classe RelaQueue

Subclasse de Queue<Type> para trabalhar com Relatorios sem a necessidade de alterar o restante do codigo

public class RelaQueue extends Queue<Relatorio>
{
 
}

Classe Simulador

Esta classe tem basicamente o msm funcionamento da classe Simulador da Parte 1, porém foram adicionadas as possibilidades de escolher a instituicao do aluno e as novas opções de comportamento, como mostrado a seguir:

Escolha uma opcao:

1-Criar Novo Aluno
2-Entregar Relatorio
3-Corrigir Relatorios
4-Sair

Opção: 1

Nome do aluno: Jose

Escolha a Instituição do aluno:

1 : Ita
2 : Usp
3 : Unicamp

Opção: 1

Escolha do tipo de aluno:

1 : Safo Preguiçoso
2 : Esforçado
3 : Summa
4 : Pemba
5 : Imprevisivel
6 : Burro
Opção: 6
Comportamento incompativel com este aluno
Alunos criados:
Jose

Neste exemplo é criado um aluno chamado Jose , que estuda no Ita , porem houve a tentative de definir seu comportamento como Burro, porém como isso é impossivel, foi mostrada a mensagem de erro, e seu comportamento ficou definido como Esforçado,que é o comportamento inicial quando o aluno é criado.

import java.util.Scanner;
 
public class Simulador
{
    private static RelaQueue queue = new RelaQueue();
    private static Aluno[] Alunos= new Aluno[30];
    private static int numAlunos = 0;
    private static Professor teacher = new Professor(queue);
 
    public static void main()
    {        
        System.out.println("Classe Simulador\n");
        boolean quit = false;
        while(!quit)
        {
            System.out.println("\n\n");
            Scanner scan = new Scanner(System.in);
 
            System.out.println("Escolha uma opcao:\n");
            System.out.println("1-Criar Novo Aluno"); 
            System.out.println("2-Entregar Relatorio");
            System.out.println("3-Corrigir Relatorios");
            System.out.println("4-Sair\n");
            System.out.print("Opção: ");
 
            String str = scan.next(); 
 
            while(!str.equals("1") && !str.equals("2") &&
                  !str.equals("3") && !str.equals("4"))
            {
                System.out.print("Opcao invalida, tente denovo.\nOpção: ");
                str = scan.next();
            }
            int opt = Integer.parseInt(str);
 
            System.out.print("\n\n");
            switch(opt)
            {
                case 1:
                criarAluno();
                break;
 
                case 2:
                fazerRelas();
                break;
 
                case 3:
                corrigirRelas();
                break;
 
                case 4:
                quit = true;
                break;
            }
        }     
    }   
    private static void criarAluno()
    {   
 
        Scanner scan = new Scanner(System.in);
 
        System.out.print("Nome do aluno: ");
        String str = scan.next();
 
        System.out.println("\nEscolha a Instituição do aluno: \n");
        System.out.println("1 : Ita");            
        System.out.println("2 : Usp");
        System.out.println("3 : Unicamp\n");
        System.out.print("Opção: "); 
        String str2 = scan.next();
        while(!str2.equals("1") && !str2.equals("2")&& !str2.equals("3"))
        {
            System.out.print("Opcao invalida, tente denovo.\nOpção: ");
            str2 = scan.next();
        }
        int instituicao = Integer.parseInt(str2);
 
        System.out.println("\nEscolha do tipo de aluno: \n");
        System.out.println("1 : Safo Preguiçoso");            
        System.out.println("2 : Esforçado");
        System.out.println("3 : Summa");
        System.out.println("4 : Pemba");
        System.out.println("5 : Imprevisivel");
        System.out.println("6 : Burro");
        System.out.print("Opção: "); 
        str2 = scan.next();
 
        while(!str2.equals("1") && !str2.equals("2")&& !str2.equals("3") &&
              !str2.equals("4") && !str2.equals("5")&& !str2.equals("6"))
        {
            System.out.print("Opcao invalida, tente denovo.\nOpção: ");
            str2 = scan.next();
        }
        int comport = Integer.parseInt(str2);
 
        Aluno novoAluno = null;
 
        switch(instituicao)
        {
            case 1:
            novoAluno = new AlunoITA(str,queue);
            break;
 
            case 2:
            novoAluno = new AlunoUSP(str,queue);
            break;
 
            case 3:
            novoAluno = new AlunoUnicamp(str,queue);
            break;
         }
         Comportamento novoComportamento = null;
         switch(comport)
         {
            case 1:novoComportamento = new SafoPreguicoso(novoAluno);break;
            case 2:novoComportamento = new Esforcado(novoAluno);break;       
            case 3:novoComportamento = new Summa(novoAluno);break;
            case 4:novoComportamento = new Pemba(novoAluno);break;
            case 5:novoComportamento = new Imprevisivel(novoAluno);break;
            case 6:novoComportamento = new Burro(novoAluno);break;            
         }
 
         try 
         {
              novoAluno.setComportamento(novoComportamento);
         }catch (Exception e)
         {
            System.out.println( "Comportamento incompativel com este aluno");
         }
 
         Alunos[numAlunos] = novoAluno;
         numAlunos++;
 
         System.out.println("Alunos criados: ");
         for(Aluno a : Alunos)
         {
             if(a!=null)System.out.println(a.getNome());
         }
    }
 
    private static void fazerRelas()
    {
         Scanner scan = new Scanner(System.in);
         System.out.println("De o nome do aluno a fazer o rela: ");
         String nome = scan.next();
         Aluno getAluno = null;
         for(Aluno a : Alunos)
         {
             if(a!=null)
             {
                 if(a.getNome().equals(nome))getAluno = a;
             }
         }
         if(getAluno==null)System.out.println("Aluno com nome "+nome+" nao existe, tente novamente.");
         else
         {
             getAluno.fazEEntregaRelatorio();
             System.out.println("Relatorio de "+nome+" entregue.");
         }
    }
 
    private static void corrigirRelas()
    {
         System.out.println("Relatorios corrigidos. Notas:");
         teacher.corrigirRelatorios();
    }
}

As classes Professor e Relatorio não foram alteradas em relação ao Lab1.

Ao aplicar a classe de teste sobre o projeto,temos que o programa passou em todos os testes , como mostra a figura a seguir:

testResults.JPG

Portanto a aplicação está funcionando corretamente.

Conclusão

Este laboratório foi bom para entender uma das aplicações do padrão strategy, que foi aplicado ao comportamento do aluno, assim como a criação de tipos genericos, usado no Queue . Nesta esperiencia também foi possivel lidar com inputs e outputs via console em java , que mostrou ser bem parecido com C.

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