Lab2 Marcus Leandro

aluno: Marcus Leandro Rosa Santos
ano/sem: 2008/2o.
data do laboratório (num. da semana) : 06/09/2008 (6)

Introdução

Esse laboratório, foi um aprimoramento do primeiro. Primeiramente introduzimos uma classe Simulador que seria responsável pela criação dos alunos com o intermédio do usuário, através de imputs dados por esse. Mudou-se a classe Aluno que antes era abstrata e agora deixou de ser, estendo classes como AlunoITA, alunoUSP e alunoUnicamp. Os tipos de aluno, não são mais sub-classes da classe aluno e sim da nova classe Comportamento implementada nesse lab, que será do tipo abstrata. A classe comportamento estenderá todos os tipos de comportamento (Summa, SafoPreguicoso, Imprevisivel etc). Para critérios dos diferentes tipos de comportamento, adotei aquele descrito na instrução do lab.

Desenvolvimento

Parte 1

Inicialmente foi criado uma classe Simulador para o código feito no primeiro laboratório, cujo código encontra-se abaixo:

import java.io.Console;
public class Simulador{
 
    public static void main( String[] args){
 
        Console console = System.console();
 
        Aluno[] aluno = new Aluno[20];
        RelaQueue rela = new RelaQueue();
        Professor teacher = new Professor(rela);
        String nome;
        String tipo;
 
        System.out.println("********Criacao dos alunos por parte do usuario.*********");
        String str  = console.readLine("entre com o numero de alunos a ser inserido:  ");
        int n = Integer.parseInt(str);
 
        for( int i = 1 ; i<=n ; i++ ){
           nome = console.readLine("entre com o nome do %d aluno: ", i );
           tipo  = console.readLine("escreva o tipo do aluno (esforçado ou safo preguiçoso): ");
           while(!tipo.equals("safo preguiçoso") && !tipo.equals("esforçado") ){
                tipo  = console.readLine("escreva o tipo do aluno (esforçado ou safo preguiçoso): ");     
           }
           if(tipo.equals("esforçado")){
                aluno[i] = new AlunoEsforcado(nome , rela); 
           }
           else{
                aluno[i] = new AlunoSafoPreguicoso(nome , rela); 
           }
        }
 
        // fazendo os alunos fazerem e entregar o relatório:
        for( int i = 1 ; i<=n ; i++){
            aluno[i].fazEEntregaRelatorio();
        }
        // fazendo o professor corrigir o relatório:
        for( int i = 1 ; i<=n ; i++){
            teacher.corrigirRelatorio();        
        }     
 
    }
 
}

rodando a classe no prompt de comando obtivemos o resultado como a imagem abaixo:

prompt1.jpg

Eis abaixo o diagrama de classes fornecido pelo bluej.

imagem1.jpg

Parte 2

Nessa segunda parte como foi pré-descrito na introdução foi feito um aprimoramento do 1º laboratório. Os critérios a serem respeitados encontram-se no link que descreve o lab http://ces22.wikidot.com/lab2

A seguir será postado todos códigos de classe feita no programa.

Classe Aluno:

public class Aluno{
 
    //variáveis:
    int conhecimento = 0;
    String nome;
    RelaQueue<Relatorio> queue;
    Comportamento comportamento ;
 
    //construtor:
    public Aluno(String nome, RelaQueue<Relatorio> queue){
        this.nome = nome;
        this.queue = queue;
        comportamento = new Esforcado(this);
    }    
    //metodos:
 
    public void fazEEntregaRelatorio(){
 
        float qualidade = (2 * this.getDedicacao() + 1 * this.getInteligencia() ) / 3 ;
        float originalidade = (1 * this.getDedicacao() + 2 * this.getInteligencia() ) / 3 ;
 
        Relatorio rela = new Relatorio(qualidade, originalidade, this);
 
        this.queue.queue(rela);
        conhecimento++;
 
    }
 
    public int getConhecimento(){
 
        return conhecimento;
 
    }
 
    public float getInteligencia(){
 
        return comportamento.getInteligencia();
    }
 
    public float getDedicacao(){
 
        return comportamento.getDedicacao();
    }
 
    public String getNome(){
        return this.nome;
 
    }    
 
    public void setComportamento(Comportamento comportamento) throws Exception{
        this.comportamento = comportamento;        
    }   
 
}

Classe AlunoITA:

public class AlunoITA extends Aluno{    
 
    //construtor;
 
    public AlunoITA(String nome, RelaQueue<Relatorio> queue) {
        super(nome, queue);
        // TODO Auto-generated constructor stub
    }
 
    //metodos;
 
    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 AlunoUnicamp:

public class AlunoUnicamp extends Aluno {
 
    //construtor:
 
    public AlunoUnicamp(String nome, RelaQueue<Relatorio> queue) {
        super(nome, queue);    
    }
 
    //metodos:
 
    public void setComportamento(Comportamento comportamento) throws Exception {
 
        if( comportamento instanceof Summa || comportamento instanceof SafoPreguicoso ) throw new Exception();    
 
        super.setComportamento(comportamento);        
    }
}

Classe AlunoUSP:

public class AlunoUSP extends Aluno{
 
    public AlunoUSP(String nome, RelaQueue<Relatorio> queue) {
        super(nome, queue);        
    }
 
    //metodos:
 
    public void setComportamento(Comportamento comportamento) throws Exception {
 
        if( comportamento instanceof Summa || comportamento instanceof SafoPreguicoso ) throw new Exception();
 
        super.setComportamento(comportamento);        
    }
}

Classe Compportmaneto;

public abstract class Comportamento {
    //variáveis de instância:
 
    Aluno aluno;
 
    //construtor:    
 
    public Comportamento(Aluno aluno){
 
        this.aluno = aluno;
    }    
 
    // métodos abstratos:
 
    public abstract float getInteligencia();
 
    public abstract float getDedicacao();
}

Classe Burro:

public class Burro extends Comportamento {    
 
    //variáveis de isntâncias:
    float inteligencia = 0;
    float dedicacao = 0;    
 
    //construtor:
 
    public Burro(Aluno aluno) {
        super(aluno);        
    }
 
    //metodos:    
 
    public float getDedicacao() {        
        return dedicacao;
    }
 
    public float getInteligencia() {        
        return inteligencia;
    }
}

Classe Pemba:

public class Pemba extends Comportamento {    
 
    //construtor:
 
    public Pemba(Aluno aluno){
        super(aluno);
    }
 
    //metodos:
 
    public float getInteligencia(){
        return (float)( Math.random()*0.5);
    }
 
    public float getDedicacao(){
        return (float)( Math.random()*0.5);
    }
}

Classe SafoPreguicoso:

public class SafoPreguicoso  extends Comportamento{
 
    //variáveis de instâncias:
 
    float inteligencia = 1;    
 
    //construtor:
 
    public SafoPreguicoso(Aluno aluno) {
        super(aluno);        
    }
 
    //metodos:
 
    public float getDedicacao() {        
        return (float) (Math.random()*0.5);
    }
 
    public float getInteligencia() {        
        return inteligencia;
    }    
 
}

Classe Esforcado:

public class Esforcado extends Comportamento {
 
    public Esforcado(Aluno aluno) {
        super(aluno);    
    }
 
    //vairáveis de instãncias:
    float inteligencia =  0.5f;
 
    float dedicacao = 1;
 
    //metodos:
    public float getDedicacao() {        
        return dedicacao;
    }
 
    public float getInteligencia() {        
        return inteligencia;
    }
 
}

Classe Summa:

public class Summa extends Comportamento {
 
    // variáveis de instância:
    float inteligencia = 1;
    float dedicacao = 1;
 
    //construtor:
    public Summa(Aluno aluno){        
        super(aluno);
    }
    //metodos:
    public float getDedicacao() {    
        return dedicacao;
    }
 
    public float getInteligencia() {        
        return inteligencia;
    }
 
}

Classe Imprevisivel:

public class Imprevisivel extends Comportamento {        
 
    //contrutor:
 
    public Imprevisivel(Aluno aluno) {
        super(aluno);        
    }
 
    //metodos:
 
    public float getDedicacao() {        
        return (float) Math.random();
    }
 
    public float getInteligencia() {        
        return (float) Math.random();
    }
}

Classe Queue<T>:

import java.util.Vector;
 
public class Queue<T> {
 
    private Vector<T> array = new Vector<T>();
    private T valor;
    private int inicio=0;
    private int fim =0;  
    public void queue(T obj) {         
        array.add(fim, obj);              
         fim = (fim + 1) % 10; 
 
    }  
    public T dequeue(){  
        if (inicio == fim){
            return null;  
         }
         else{
             valor = array.get(inicio);
             inicio = (inicio + 1) % 10;
             return valor;
         } 
    }    
}

Classe RelaQueue<T>:

public class RelaQueue<T> extends Queue<T>{}

Classe Professor:

public class Professor {
    //variaveis
    RelaQueue<Relatorio> queue;
 
    //construtor
    public Professor(RelaQueue<Relatorio> queue){
        this.queue = queue; 
    }
 
    private float corrigirRelatorio(Relatorio rela){
        float nota = (float) ((( rela.getQualidade() + rela.getOriginalidade() + Math.random() ) / 3) * 10);
 
        return nota;
 
    }
 
    public void corrigirRelatorio(){
        Relatorio relaCorrecao;
 
        while(( relaCorrecao = this.queue.dequeue() )!= null){        
        float nota = corrigirRelatorio(relaCorrecao);    
 
        System.out.println( relaCorrecao.getAluno().getNome() + ": " + nota);
 
        }
    }
}

Classe Relatorio:

public class Relatorio {
    //atributos -> variáveis de instância
    float qualidade;
    float originalidade;
    Aluno aluno;
 
    //construtor
    public Relatorio(float qualidade, float originalidade, Aluno aluno){
        this.qualidade = qualidade; 
        this.originalidade = originalidade;
        this.aluno = aluno;
    }
 
    //métodos
 
    public float getQualidade(){
        return this.qualidade;
    }
 
    public float getOriginalidade(){
        return this.originalidade;        
    } 
 
    public Aluno getAluno(){
        return aluno;
    }    
}

Classe Simulador:

import java.io.Console;
 
public class Simulador{
 
    public static void main(String[] args){
 
        Console console = System.console();
 
        Aluno[] aluno = new Aluno[20];
        RelaQueue<Relatorio> rela = new RelaQueue<Relatorio>();
        Professor teacher = new Professor(rela);
        String nome , universidade , comportamento;
 
        System.out.println("*************Criacao dos alunos por parte do usuario.*************");
        String str  = console.readLine("entre com o numero de alunos a ser inserido:  ");
        int n = Integer.parseInt(str);
 
        for( int i = 1 ; i<=n ; i++ ){
 
           nome = console.readLine("entre com o nome do %d aluno: ", i ); 
 
           universidade = console.readLine("entre com a faculdade do aluno (ITA, USP ou Unicamp): ");
           while(!universidade.equals("ITA") && !universidade.equals("USP") && !universidade.equals("Unicamp") )
               universidade = console.readLine("entre com a faculdade do aluno (ITA, USP ou Unicamp): ");               
 
           if(universidade.equals("ITA") ) {
               aluno[i] = new AlunoITA(nome, rela);
           }
           else if(universidade.equals("USP")) {
               aluno[i] = new AlunoUSP(nome, rela);
           }
           else aluno[i] = new AlunoUnicamp(nome,rela);
 
           comportamento = console.readLine("entre com o comportamento do aluno(SafoPreguicoso, Summa , Esfocado, Imprevisivel, Pemba e Burro): ");
           while(!comportamento.equals("SafoPreguicoso") && !comportamento.equals("Summa") && comportamento.equals("Esforcado") && comportamento.equals("Imprevisivel") && comportamento.equals("Pemba") && comportamento.equals("Burro"))
               comportamento = console.readLine("entre com o comportamento do aluno(SafoPreguicoso, Summa , Esfocado, Imprevisivel, Pemba e Burro): ");    
 
           if( comportamento.equals("SafoPreguicoso") ) {
               try{
                   aluno[i].setComportamento(new SafoPreguicoso(aluno[i]) );
               } catch(Exception e) {
                   System.out.println("Você tentou fazer algo impossível!");
               }
           }
           else if (comportamento.equals("Esforçado")) {
               try {
                   aluno[i].setComportamento(new Esforcado(aluno[i]) );
               } catch(Exception e) {
                   System.out.println("Você tentou fazer algo impossível!");
               }
           }     
           else if(comportamento.equals("Pemba")) {
               try{
                   aluno[i].setComportamento(new Pemba(aluno[i]) );
               } catch(Exception e) {
                   System.out.println("Você tentou fazer algo impossível!");
               }
           }
           else if(comportamento.equals("Burro") ) {
               try {
                   aluno[i].setComportamento(new Burro(aluno[i]) );
               } catch(Exception e){
                   System.out.println("Você tentou fazer algo impossível!");
               }
           }
           else if(comportamento.equals("Imprevisivel") ) {
               try{
                   aluno[i].setComportamento(new Imprevisivel(aluno[i]) );
               } catch(Exception e) {
                   System.out.println("Você tentou fazer algo impossível!");
               }
           }
           else{
               try{
                   aluno[i].setComportamento(new Summa(aluno[i]) );
               } catch(Exception e) {
                   System.out.println("Você tentou fazer algo impossível!");
               }
           }
        }          
 
        // fazendo os alunos fazerem e entregar o relatório:
        for( int i = 1 ; i<=n ; i++){
            aluno[i].fazEEntregaRelatorio();
        }
        // fazendo o professor corrigir o relatório:
        for( int i = 1 ; i<=n ; i++){
            teacher.corrigirRelatorio();        
        }     
 
    }
 
}

Classe Teste:

public class Teste {
 
    public void testFuncionaComoOLab1() {
          //criando os objetos
          RelaQueue<Relatorio> queue = new RelaQueue<Relatorio>();
          Professor prof = new Professor(queue);
 
          // O que muda em termos de interface externa neste lab,
          // é a criação dos alunos. O que mostra que o nosso código
          // está bem desacoplado e a nossa refatoração não alterou
          // o funcionamento dos outros objetos (Professor, Relatório, etc).
            Aluno aluno1 = new Aluno("John Smith", queue);
            Aluno aluno2 = new Aluno("Mark Smith", queue);
            Aluno aluno3 = new Aluno("Joseph Smith", queue);
            Aluno aluno4 = new Aluno("Robert Smith", queue);
         try {
            aluno3.setComportamento( new SafoPreguicoso(aluno3) );
            aluno4.setComportamento( new SafoPreguicoso(aluno4) );
          } catch (Exception e) {
           System.out.println("Não deveria lançar erro!");
          }
 
          //teste de alunoesforcado
          assertEquals(0.5, aluno1.getInteligencia(), 0.01);
          assertEquals(1, aluno1.getDedicacao(), 0.01);
 
          //teste de alunosafo
          assertEquals(1.0, aluno3.getInteligencia(), 0.01);
          assertTrue(aluno3.getDedicacao() != aluno3.getDedicacao()); //deve ser randomica
          assertTrue(aluno3.getDedicacao() < 0.5);
 
          //alunos comecam a fazer os relas
          aluno1.fazEEntregaRelatorio();
 
         //roubamos o relatório do primeiro aluno para investigá-lo
          Relatorio rela1 = queue.dequeue();
          assertEquals(aluno1, rela1.getAluno());
          assertTrue(rela1.getAluno().getNome().equals("John Smith"));
          assertTrue(rela1.getQualidade() < 0.9);
          assertTrue(rela1.getQualidade() > 0.8);
          assertTrue(rela1.getOriginalidade() < 0.7);
          assertTrue(rela1.getOriginalidade() > 0.6);
 
          //os outros continuam a fazer os relas
          aluno2.fazEEntregaRelatorio();
          aluno3.fazEEntregaRelatorio();
          aluno4.fazEEntregaRelatorio();
 
          //deve exibir a coreção dos relas dos aluno2, aluno3, e aluno4, nesta ordem
          //pois "roubamos" o relatório do aluno1
          prof.corrigirRelatorio();
        }
 
        private void assertEquals(Aluno aluno1, Aluno aluno) {}
 
        private void assertTrue(boolean b) {}
 
        private void assertEquals(double d, float inteligencia, double e) {}
 
        private void assertEquals(float f, float inteligencia, float g) {}
 
        public void testOsComportamentosFuncionamComoEspecificado() {
          RelaQueue<Relatorio> queue = new RelaQueue<Relatorio>();
          Aluno aluno1 = new Aluno("John", queue);
          Comportamento summa = new Summa(aluno1);
          Comportamento pemba = new Pemba(aluno1);
          Comportamento imprevisivel = new Imprevisivel(aluno1);
          Comportamento safo = new SafoPreguicoso(aluno1);
          Comportamento esforcado = new Esforcado(aluno1);
          Comportamento burro = new Burro(aluno1);
 
         //teste de esforcado
          assertEquals(0.5, esforcado.getInteligencia(), 0.01);
          assertEquals(1, esforcado.getDedicacao(), 0.01);
 
        //teste de burro
          assertEquals(0.0, burro.getInteligencia(), 0.01);
          assertEquals(0.0, burro.getDedicacao(), 0.01);
 
        //teste de summa
          assertEquals(1.0, summa.getInteligencia(), 0.01); 
          assertEquals(1.0, summa.getDedicacao(), 0.01);
 
          //teste de safo
          assertEquals(1.0, safo.getInteligencia(), 0.01);
          assertTrue(safo.getDedicacao() != safo.getDedicacao()); //deve ser randomica
          assertTrue(safo.getDedicacao() < 0.5);
 
          //teste de imprevisivel
          assertTrue(imprevisivel.getInteligencia() != imprevisivel.getInteligencia()); //deve ser randomica
          assertTrue(imprevisivel.getInteligencia() < 1.0);
          assertTrue(imprevisivel.getDedicacao() != imprevisivel.getDedicacao()); //deve ser randomica
          assertTrue(imprevisivel.getDedicacao() < 1.0);
 
          //teste de pemba
          assertTrue(pemba.getInteligencia() != pemba.getInteligencia()); //deve ser randomica
          assertTrue(pemba.getInteligencia() < 0.5);
          assertTrue(pemba.getDedicacao() != pemba.getDedicacao()); //deve ser randomica
          assertTrue(pemba.getDedicacao() < 0.5);
 
        }
 
        public void testAsSubClassesDeAlunoTemRestricoes() {
            RelaQueue<Relatorio> queue = new RelaQueue<Relatorio>();
            AlunoITA alunoITA = new AlunoITA("John Smith", queue);
            AlunoUSP alunoUSP = new AlunoUSP("Mark Smith", queue);
            AlunoUnicamp alunoUnicamp = new AlunoUnicamp("Joseph Smith", queue);
         try {
            alunoITA.setComportamento( new SafoPreguicoso(alunoITA) );
            alunoITA.setComportamento( new Summa(alunoITA) );
            alunoUSP.setComportamento( new Burro(alunoUSP) );
            alunoUnicamp.setComportamento( new Burro(alunoUnicamp) );
          } catch (Exception e) {
            System.out.println("Não deveria lançar erro!");
          }
         try {
            alunoITA.setComportamento( new Burro(alunoITA) );
            System.out.println("Deveria lançar erro!");
          } catch (Exception e) {
          }
         try {
            alunoUSP.setComportamento( new SafoPreguicoso(alunoUSP) );
            System.out.println("Deveria lançar erro!");
          } catch (Exception e) {
          }
         try {
            alunoUnicamp.setComportamento( new Summa(alunoUnicamp) );
            System.out.println("Deveria lançar erro!");
          } catch (Exception e) {
          }
        }
 
        public void testRelaQueueEhSubclasseDoGenericoQueue() {
          Queue<Relatorio> q = new RelaQueue(); //propriedade básica do polimorfismo
        }    
}

A classe simulador desse projeto foi rodada assim como a anterior no prompt de comando cujo resultado encontra-se abaixo:

prompt2.jpg

A seguir segue o diagrama de classes dado pelo bluej:

imagem2.jpg

Por fim Testou-se os quatro métodos da classe Teste, verificando que todos estavam sem erros, implicando um bom funcionamento do programa,a baixo segue a imagem do teste.

teste.jpg

Conclusão

Nesse laboratório, apesar de muito trabalhoso, foi fundamental para o o aprendizado e aplicação de como usar o método genéricos e o tratamento de exceções. Observamos a vantagem da linguagem orientada objetos quando se deseja fazer uma modificação no seu código, observei que não é necessário mecher em todo a sua estrutura e sim criar novas classes, sem mecher no código anterior.

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