Lab2 Marcus Edson

aluno: Marcus Edson Barreto Brito
ano/sem: 2008/2o.
data do laboratório (4a. semana) : 06/08/2008 (2)

Introdução

Primeiramente criamos uma classe simulador para o primeiro laboratório, de modo que nossa aplicação pudesse ser utilizada por um usuário qualquer.
A seguir realizamos algumas modificações no programa do laboratório 1 de para que ele tivesse mais funcionalidades. Primeiramente estendemos o número de comportamentos que um aluno poderia receber. Também classificamos um aluno como pertencente a uma universidade (ITA, USP ou Unicamp). Fizemos também um tratamento de exceções, de modo que dependendo da universidade, um aluno não poderia ter certos comportamentos. Criamos também uma classe Queue<T>,que é uma fila de objetos genéricos, e não só de relatórios como no Lab1. Por último fizemos uma classe Simulador, semelhante à feita para o Lab1.

Desenvolvimento

Primeiramente fizemos uma classe simulador para o primeiro laboratório, de modo que um usuário pudesse criar vários alunos dizendo qual era seu comportamento e a seguir eles fariam seus relatórios e o professor corrigiria e daria as notas. A classe simulador do 1o.Lab é mostrada abaixo:

Simulador do primeiro Lab

import java.util.Scanner;
 
public class Simulador{
 
    public void main(){
        int cont=0;
        Aluno[] aluno = new Aluno[10];
        RelaQueue queue = new RelaQueue();
 
        Scanner sc = new Scanner(System.in);
 
        System.out.println("Inserir novo aluno?(s/n): ");
        String inserir = sc.nextLine();
        while(!inserir.equals("s") && !inserir.equals("n")){
        System.out.println("Inserir novo aluno?(s/n): ");
        inserir = sc.nextLine();    
        }
 
        while(inserir.equals("s")){
            System.out.println("Digite o nome do aluno: ");
            String nome = sc.nextLine(); 
 
            System.out.println("Diga se o aluno eh ´safo´ ou ´esforcado´: ");
            String tipo = sc.nextLine();
            while(!tipo.equals("safo") && !tipo.equals("esforcado")){
                System.out.println("Diga se o aluno eh ´safo´ ou ´esforcado´: ");
                tipo = sc.nextLine(); 
            }
 
            if(tipo.equals("safo")){
                aluno[cont] = new AlunoSafoPreguicoso(nome, queue);
                cont++;
            }
            else if(tipo.equals("esforcado")){
                aluno[cont] = new AlunoEsforcado(nome, queue);
                cont++;
            }
 
            System.out.println("Inserir novo aluno?(s/n): ");
            inserir = sc.nextLine();
            while(!inserir.equals("s") && !inserir.equals("n")){
                System.out.println("Inserir novo aluno?(s/n): ");
                inserir = sc.nextLine();    
            }
        }
 
        Professor Prof=new Professor(queue);
        int i=0;
        for(i=0;i<cont;i++){
            aluno[i].fazEEntregaRelatorio();
        }
        System.out.println("Todos os alunos ja entregaram os relatorios.");
        System.out.println("Digite qualquer tecla para o professor corrigir os relatorios: ");
        String corrige=sc.nextLine();
        Prof.corrigirRelatorios();
    }   
 
}

Testes realizados no primeiro simulador:

simulador_lab1.JPG

A seguir, a segunda parte do laboratório, que consistiu em algumas mudanças descritas na introdução.

Classe aluno

public class Aluno 
{
    private Comportamento comp;    
    private int conhecimento=0;
    private String nome;
    private RelaQueue queue;
 
    //Construtor
    public Aluno(String str, RelaQueue que){
        this.nome=str;
        this.queue=que;
        comp=new Esforcado(this);
    } 
 
    //retorna um inteiro com o conhecimento do aluno
    public int getConhecimento(){
        return conhecimento;            
    }
 
    //método público(pode ser acessado por outras classes)
    //Cria o relatorio do aluno com os parametro originalidade e qualidade e o 
    //coloca o relatório do aluno numa fila de relatórios 
    public void fazEEntregaRelatorio(){
        float qualidade = (2 * this.getDedicacao() + this.getInteligencia() ) / 3 ;
        float originalidade = (this.getDedicacao() + 2 * this.getInteligencia() ) / 3 ;
        Relatorio rela = new Relatorio(qualidade, originalidade, this);
        queue.queue(rela);
        conhecimento++;
    }
 
    //retorna a string com o nome do aluno
    public String getNome(){
        return nome;
    }
 
    public float getInteligencia(){
        return this.comp.getInteligencia();
    }
 
    public float getDedicacao(){
        return this.comp.getDedicacao();    
    }
 
    //método que permite modificar o comportamento do aluno, 
    //que é inicialmente colocado como Esforcado
    public void setComportamento(Comportamento comportamento) throws Exception{
        this.comp=comportamento;
    }
 
    //método adicionado para facilitar a verificação da nota com o tipo do aluno
    public Comportamento getComportamento(){
        return comp; 
    }
 
}

Subclasse AlunoITA

//Subclasse de Aluno
public class AlunoITA extends Aluno{
    //Construtor
    public AlunoITA(String str, RelaQueue que){
        super(str,que);
    }
 
    //Sobrescreve o método da superclasse Aluno de modo a não permitir determinados
    //comportamentos para esta subclasse.
    //Nesse caso o AlunoITA não pode ser setado como Burro
    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.
    }
 
}

Subclasse AlunoUSP

//Subclasse de Aluno
public class AlunoUSP extends Aluno{
 
    //Construtor
    public AlunoUSP(String str, RelaQueue que){
        super(str,que);
    }
 
    //Sobrescreve o método da superclasse aluno de modo a não permitir determinados
    //comportamentos para esta subclasse.
    //Nesse caso o aluno não pode ser nem Summa nem SafoPreguicoso 
    public void setComportamento(Comportamento comportamento) throws Exception {
        if( (comportamento instanceof Summa) || (comportamento instanceof SafoPreguicoso) ) throw new Exception();
        super.setComportamento(comportamento);
    }
}

A subclasse AlunoUnicamp é análoga à AlunoUSP

Classe abstrata Comportamento

//Classe abstrata que será posteriormente sobrescrita
public abstract class Comportamento{
    private Aluno aluno;
 
    //Construtor
    public Comportamento(Aluno aluno){
        this.aluno = aluno;
    }
 
    //Métodos abstratos.
    //Serão sobrescritos pelas suas subclasses, retornado valores 
    //de inteligência e dedicação de acordo com cada subclasse
    public abstract float getInteligencia();
    public abstract float getDedicacao();
}

Essa classe é sobrescrita por seis diferentes comportamentos. Em cada um deles tínhamos diferentes valores de inteligência e dedicação, podendo ser números aleatórios entre 0 e 1 (ou entre 0e 0,5) ou podendo ser números fixos (no máximo 1).
Abaixo vejamos 3 exemplos dessas subclasses, pois as outras são semelhantes:

Aluno Summa

Nessa classe inteligencia e dedicação são ambos 1.

//Subclasse que implementa o comportmaento Summa
public class Summa extends Comportamento {
 
    private float dedicacao=1f;
    private float inteligencia=1f;
 
    public Summa(Aluno aluno){
        super (aluno);
    }
 
    public float getInteligencia(){
        return inteligencia;
    }
 
    public float getDedicacao(){
        return dedicacao;
    }
}

Aluno SafoPreguicoso

Nessa classe temos inteligencia=1 e dedicação variando de 0 a 0.5.

import java.util.*;
//Subclasse que implementa o comportmaento SafoPreguicoso
public class SafoPreguicoso extends Comportamento {
 
    private float inteligencia=1f;
 
    public SafoPreguicoso(Aluno aluno){
        super (aluno);
    }
 
    public float getInteligencia(){
        return inteligencia;
    }
 
    public float getDedicacao(){
        Random generator = new Random();
        float r = generator.nextFloat();
        return r/2;
    }
}

Aluno Pemba

Nessa classe temos inteligencia e dedicação variando de 0 a 0.5.

import java.util.*;
//Subclasse que implementa o comportmaento Pemba 
public class Pemba extends Comportamento {
 
    public Pemba(Aluno aluno){
        super (aluno);
    }
 
    public float getInteligencia(){
        Random generator = new Random();
        float r = generator.nextFloat();
        return r/2;
    }
 
    public float getDedicacao(){
        Random generator = new Random();
        float r = generator.nextFloat();
        return r/2;
    }
}

Classe Queue<T>

import java.util.Vector;
//Classe que é uma fila de elementos de tipo não restrito. 
public class Queue<T>{
 
    private Vector<T> array = new Vector<T>();
    private int inicio=0, fim=0;
 
    public void queue(T obj){
        array.add(fim,obj);
        fim=(fim+1)%10;
    }
 
    public T dequeue(){
        if(inicio!=fim){
            T elem=array.get(inicio);
            inicio=(inicio+1)%10;
            return elem;
        }
        else{
            return null;
        }
    }
}

As classes Professor e Relatório não tiveram mudanças significativas em relação ao primeiro Lab.

Diagrama de Classes

A seguir o diagrama de classes do segundo laboratório:
diag_classes_lab2.JPG

Classe Teste

Resultado da execução da classe teste:
teste_all_lab2.JPG

Segundo Simulador

import java.util.*;
//Classe simulador, que vai permitir a um usuário criar alguns aluno, dizer a universidade
//à qual ele pertence e o seu comportamento.
//A seguir os alunos irão fazer e o relatório e o professor vai retornar suas notas.
public class Simulador{
 
    public void main(){
        int cont=0;
        Aluno[] aluno = new Aluno[20];
        RelaQueue queue = new RelaQueue();
 
        Scanner sc = new Scanner(System.in);
 
        //Pergunta se o usuáro deseja inserir um novo aluno
        System.out.println("Inserir novo aluno?(s/n): ");
        String inserir = sc.nextLine();
        while(!inserir.equals("s") && !inserir.equals("n")){
        System.out.println("Inserir novo aluno?(s/n): ");
        inserir = sc.nextLine();    
        }
 
        //Loop para que o usuário possa inserir vários alunos.        
        while(inserir.equals("s")){
            System.out.println("Digite o nome do aluno: ");
            String nome = sc.nextLine(); 
 
            //Pergunta ainstituição do aluno
            System.out.println("Diga o número correspondente a universidade a qual o aluno pertence: ");
            System.out.println("1-ITA | 2-USP | 3-Unicamp");
            String inst = sc.nextLine();
            while(!inst.equals("1") && !inst.equals("2") && !inst.equals("3")){
                System.out.println("Tipo inválido. Diga o número correspondente a universidade do aluno: ");
                inst = sc.nextLine(); 
            }
 
            //Pergunta o tipo de aluno
            System.out.println("Diga o número correspondente ao comportmaneto do aluno: ");
            System.out.println("1-Esforcado | 2-Safo | 3-Summa | 4-Pemba | 5-Burro | 6-Imprevisivel");
            String tipo = sc.nextLine();
            while(!tipo.equals("1") && !tipo.equals("2") && !tipo.equals("3") && !tipo.equals("4") && !tipo.equals("5") && !tipo.equals("6")){
                System.out.println("Tipo inválido. Diga o número correspondente ao comportmaneto do aluno: ");
                tipo = sc.nextLine(); 
            }
 
            //Cria um aluno de uma das 3 universidades 
            //de acordo com o que fopi passado pelo usuário
            if(inst.equals("1")){
                aluno[cont] = new AlunoITA(nome, queue);
            }
            else if(inst.equals("2")){
                aluno[cont] = new AlunoUSP(nome, queue);
            }
            else if(inst.equals("3")){
                aluno[cont] = new AlunoUnicamp(nome, queue);
            }
 
            //Seta o comportamento do aluno de acordo com o que 
            //foi passado pelo usuário.
            //Observe que nesse caso é feito o tratamento de exceções, 
            //já que um aluno de determinada universidade não pode 
            //ter determinados comportamentos
            if(tipo.equals("1")){
                try {
                    aluno[cont].setComportamento(new Esforcado(aluno[cont]));
                }catch(Exception e){
                    System.out.println("Você tentou fazer algo impossível!");
                }
            }
            else if(tipo.equals("2")){
                try {
                    aluno[cont].setComportamento(new SafoPreguicoso(aluno[cont]));
                }catch(Exception e){
                    System.out.println("Você tentou fazer algo impossível!");
                }
            }
            else if(tipo.equals("3")){
                try {
                    aluno[cont].setComportamento(new Summa(aluno[cont]));
                }catch(Exception e){
                    System.out.println("Você tentou fazer algo impossível!");
                }
            }
            else if(tipo.equals("4")){
                try {
                    aluno[cont].setComportamento(new Pemba(aluno[cont]));
                }catch(Exception e){
                    System.out.println("Você tentou fazer algo impossível!");
                }
            }
            else if(tipo.equals("5")){
                try {
                    aluno[cont].setComportamento(new Burro(aluno[cont]));
                }catch(Exception e){
                    System.out.println("Você tentou fazer algo impossível!");
                }
            }            
            else if(tipo.equals("6")){
                try {
                    aluno[cont].setComportamento(new Imprevisivel(aluno[cont]));
                }catch(Exception e){
                    System.out.println("Você tentou fazer algo impossível!");
                }
            }            
 
            cont++;
 
            System.out.println("Inserir novo aluno?(s/n): ");
            inserir = sc.nextLine();
            while(!inserir.equals("s") && !inserir.equals("n")){
                System.out.println("Inserir novo aluno?(s/n): ");
                inserir = sc.nextLine();    
            }
        }
 
        //Cria um professor, manda os alunos fazerem e entregarem os relatórios 
        //e a seguir o professor corrige e lança as notas.         
        Professor Prof=new Professor(queue);
        int i=0;
        for(i=0;i<cont;i++){
            aluno[i].fazEEntregaRelatorio();
        }
        System.out.println("Todos os alunos ja entregaram os relatorios.");
        System.out.println("Digite 'enter' para o professor corrigir os relatorios.");
        String corrige=sc.nextLine();
        Prof.corrigirRelatorios();
    }   
 
}

Testes realizados no segundo simulador:

simulador_lab2_p1.JPG
simulador_lab2_p2.JPG

O código fonte do lab2 se encontra no link ao lado: CES22_lab2

Conclusão

Neste laboratório pudemos pôr em prática alguns conceitos de programação orientada a objetos vistos em sala.
Pudemos trabalhar com novas características da linguagem JAVA, como o tratamento de exceções, a criação de um vetor de elementos genéricos e a entrada de dados por um usuário.
Pudemos também perceber a importância de um bom modelamento das classes ao se programar usando OO, para que o programa possa sofrer melhorias sem que se tenha que reescrevê-lo.

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