Lab2 Cicero David

aluno: Cicero David Leite Oliveira
ano/sem: 2008/2o.
data do laboratório (4ª semana) : 06/08/2008

Introdução

Nessa prática, realizamos a evolução do do que foi desenvolvido no primeiro laboratório através de mudanças nas classes criadas, implementando uma nova estrutura com relacionamentos diferentes. També foi desenvolvida uma classe para realizar a interface com o usuário.

Desenvolvimento

Para desenvolve o código, foi utilizado o ambiente de desenvolvimento NetBeans IDE 6.1 ou invés do BlueJ, pois o primeiro possui uma interface melhor e falcilita mais o desenvolvimento.
Inicialmente mudamos a forma de implementar o comportamento dos alunos, ao invés de criar subclasses que representam alunos com determinado comportamento, criamos uma classe abstrata Comportamento e suas subclasses para cada tipo de comportamento. Assim, um aluno possuia uma variável do tipo Comportamento e um Comportamento possui uma variável do tipo Aluno.
Tem-se então o código para a classe Comportamento:

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

Pode-se ver o a classe contém somente os métodos abstratos getDedicacao() e getInteligencia() que serão sobescrevidos por suas sub-classes.
Em seguida, modificaram-se as subclasses SafoPregiuicoso e Esforcado e criou-se mais 4 classes semelhantes: Summa, Pemba, Imprevisivel e Burro. Todas são semelhantes, mudando somente a implementação dos métodos. Para exemplificar o código destas sub-classes, tem-se o código da classe Summa:

package entidades;
 
public class Summa extends Comportamento
{
 
    private float inteligencia;
    private float dedicacao;
 
    //contrutor que realza a chamada do contrutor da super classe e define os atributos
    public Summa(Aluno aluno)
    {
        super(aluno);
        inteligencia = 1.f;
        dedicacao = 1.f;
    }
 
    public float getInteligencia(){
        return this.inteligencia;
    }
 
    public float getDedicacao(){
        return this.dedicacao;    
    }
}

O próximo passo do desenvolvimento consistiu em implementar os tipos de faculdade que o aluno poderia estudar. Para tanto utilizou-se mais uma vez a herença, criando-se 3 subclasses da classe Aluno: AlunoITA, AlunoUSP, AlunoUnicamp. Nesse ponto, notou-se a vantagem da utilzação do padrão estabelecido para a implementação do comportamento, pois, caso contrário, seria necessário criar cinco subclasses para cada faculdade, como por exemplo AlunoITASafoPreguicoso, AlunoITASumma…
Também podereia ter sido utilizado o mesmo padrão utilizado para implementar o comportamento para definir o tipo de faculdade dos alunos. Podia ser criada uma classe Faculdade, com subclasses, ITA, USP e Unicamp. Assim, um objeto da classe Faculdade seria um atributo de Aluno.
A classe Aluno continuou baseicamente igual ai lab anterior, retirando somente sua característica de abstrata e adicionando o atributo do tipo Comportamento. Observe que o comportamento defindo como default é o Esforcado.

package entidades;
 
/**
 * Write a description of class Aluno here.
 * 
 * @author (your name) 
 * @version (a version number or a date)
 */
public class Aluno
{
    private int conhecimento = 0;
    private String nome;
    private RelaQueue queue = new RelaQueue();
    private Comportamento comportamento;
 
    public Aluno(String n, RelaQueue rel){
        this.nome = n;
        this.queue = rel;
        comportamento = new Esforcado (this);
    }
 
    public void fazEEntregaRelatorio(){
        Relatorio rela;
        rela = new Relatorio((2 * this.comportamento.getDedicacao() + 1 * this.comportamento.getInteligencia() ) / 3 , (1 * this.comportamento.getDedicacao() + 2 * this.comportamento.getInteligencia() ) / 3, this);
        queue.queue(rela);
        this.conhecimento++;
 
    }
 
   public float getInteligencia(){
       return comportamento.getInteligencia();
   }
   public float getDedicacao(){
       return comportamento.getDedicacao();
   }
 
    public int getConheciomento(){
 
        return this.conhecimento;
    }
 
    public String getNome(){
        return this.nome;
    }
 
    public void setComportamento(Comportamento comportamento) throws Exception{
 
        this.comportamento = comportamento;
    }
}

Na implementação das subclasses realizamos um tratamento de exceções com o intuito da adicionar à lógica do programa o fato de alunos de determinada faculdade não poder possuir determinado comportamento, por exemplo, somente um AlunoITA pode ter comportamento Summa. Abaixo, tem-se o código da classe AlunoUSP.

package entidades;
 
public class AlunoUSP extends Aluno{
 
    public AlunoUSP(String n, RelaQueue rel) {
        super(n, rel);
    }
 
    public void setComportamento(Comportamento comportamento) throws Exception {
 
        if ((comportamento instanceof Summa)||(comportamento instanceof SafoPreguicoso) ) throw new Exception();
        super.setComportamento(comportamento);
    }
}

O próximo passo da prática objetivou a implementação de genéricos. Foi criada uma classe Queue utilizando genéricos e seguida modificou-se a classe RelaQueue para que ela fosse subclasse da primeira. Abaixo temos o código da classe Queue.

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

Nesse ponto, ocorreu uma dificuldade na implementação da fila, pois inicialmente tentou-se trabalhar com variáveis do tipo Array ou ArrayList em vez de Vector, mas a API não suporta tratar as classes juntamento com genéricos da forma que foi implementado acima.
A classe RealQueueconsiste basicamente de subclasse de Queue, entretanto já definido o tipo de objeto da queue como Relatorio.

package entidades;
 
public class RelaQueue extends Queue<Relatorio>
{
 
 @Override 
public void queue (Relatorio rela)
{
    super.queue(rela);
}
@Override
public Relatorio dequeue()
{
   return super.dequeue();
}
 
}

Com quase todas as classes do programa já criadas, restando somente a implementação da classe Simulador, que realiza interface com usuário, resulveu-se realizar os testes com a classe Junit sugerida na instrução, para que fosse possível validar as classes criadas. A figura abaixo mostra o resultado da execução do teste, onde viu-se que todos passaram.

Por último, foi criada a classe Simulador, que realiza a interface com o usuário. A classe solicita que o usuário insira nome, faculdade e comportamento, verificando se são válidos. Após o usuário criar todos os alunos desejados o sistema exibe os atributos de da aluno e faz a correção dos relatórios de cada aluno. Para armazenar os alunos, criou-se um ArrayList de alunos e em seguida realizou-se acesso aos obejtos da lista através de um Iterator criado a partir do ArrayList. Abaixo tem-se o código do ArrayList:

package principal;
 
import entidades.*;
import java.util.*;
 
public class Simulador {
 
    public static void main(String[] Args) {
 
        RelaQueue relaQueue = new RelaQueue();
        Aluno aluno = new Aluno(null, null);
        ArrayList alunos = new ArrayList();
        Professor professor = new Professor(relaQueue);
        Boolean nomeValido = false;
 
        String continua = "S";
 
        Scanner s = new Scanner(System.in);
 
        while (continua.toUpperCase().equals("S")) {
 
            nomeValido = false;
            while (!nomeValido) {
 
                System.out.println("Entre com a faculdade do aluno:(ITA, USP, Unicamp) :");
                String faculdade = s.next();
 
                if (faculdade.toUpperCase().equals("ITA")) {
                    System.out.println("Entre com o nome do aluno:");
                    aluno = new AlunoITA(s.next(), relaQueue);
                    nomeValido = true;
 
                } else if (faculdade.toUpperCase().equals("USP")) {
                    System.out.println("Entre com o nome do aluno:");
                    aluno = new AlunoUSP(s.next(), relaQueue);
                    nomeValido = true;
 
                } else if (faculdade.toUpperCase().equals("UNICAMP")) {
                    System.out.println("Entre com o nome do aluno:");
                    aluno = new AlunoUnicamp(s.next(), relaQueue);
                    nomeValido = true;
                } else {
                    System.out.println("\nFaculadade invalida");
                }
 
            }
 
            nomeValido = false;
 
            while (!nomeValido) {
                System.out.println("Entre com o comportamento do Aluno: (burro, esforcado, imprevisivel, pemba, safopreguicoso, summa : ");
                String tipoComportamento = s.next();
 
                Comportamento comportamento;
 
                if (tipoComportamento.toUpperCase().equals("BURRO")) {
 
                    try {
                        comportamento = new Burro(aluno);
                        aluno.setComportamento(comportamento);
                        nomeValido = true;
                    } catch (Exception e) {
                        System.out.println("Comportamento incompatível");
                    }
                } else if (tipoComportamento.toUpperCase().equals("ESFORCADO")) {
                    try {
                        comportamento = new Esforcado(aluno);
                        aluno.setComportamento(comportamento);
                        nomeValido = true;
                    } catch (Exception e) {
                        System.out.println("Comportamento incompatível");
                    }
                } else if (tipoComportamento.toUpperCase().equals("IMPREVISIVEL")) {
                    try {
                        comportamento = new Imprevisivel(aluno);
                        aluno.setComportamento(comportamento);
                        nomeValido = true;
                    } catch (Exception e) {
                        System.out.println("Comportamento incompatível");
                    }
                } else if (tipoComportamento.toUpperCase().equals("PEMBA")) {
                    try {
                        comportamento = new Pemba(aluno);
                        aluno.setComportamento(comportamento);
                        nomeValido = true;
                    } catch (Exception e) {
                        System.out.println("Comportamento incompatível");
                    }
                } else if (tipoComportamento.toUpperCase().equals("SAFOPREGUICOSO")) {
                    try {
                        comportamento = new SafoPreguicoso(aluno);
                        aluno.setComportamento(comportamento);
                        nomeValido = true;
                    } catch (Exception e) {
                        System.out.println("Comportamento incompatível");
                    }
                } else if (tipoComportamento.toUpperCase().equals("SUMMA")) {
                    try {
                        comportamento = new Summa(aluno);
                        aluno.setComportamento(comportamento);
                        nomeValido = true;
                    } catch (Exception e) {
                        System.out.println("Comportamento incompatível");
                    }
                } else {
                    System.out.println("\nComportamento invalido.");
 
                }
                if (nomeValido) alunos.add(aluno);
 
            }
            System.out.println("Deseja criar mais um aluno? S/N");
            continua = s.next();
 
        }
 
        Iterator iteratorAlunos = alunos.iterator();
 
        while (iteratorAlunos.hasNext()) {
            Aluno aux = (Aluno) iteratorAlunos.next();
            aux.fazEEntregaRelatorio();
            System.out.println("Nome: " + aux.getNome() + "  Dedicacao: " + aux.getDedicacao() +
                    "  Inteligencia: " + aux.getInteligencia() + " Conhecimento: " + aux.getConheciomento());
 
        }
 
        professor.corrigirRelatorios();
 
    }
}

Para verificar o funcinamento da classe Simulador realizou-se o teste com resultado mostrado na figura abaixo:

Para finalizar a prática importou-se as classes para o JBlue, com o intuito de vizualizar graficamente os relacionamentos entre as classes.

Conclusão

A prática possibilitou ao aluno aprender basicamente dois pontos novos: o Strategy e Genéricos. Houve pocuas dificuldades na implementação, exceto na implementação da classe Queue. Um ponto que merece ser observado é que o NetBeans sugere o uso de Annotations quando se realiza a sobescrição de métodos na implementação de Herança, talvez fosse interessante abordar esse tema durante a intrução da prática.

Bernardo de Padua 1223498843|%e %b %Y, %H:%M %Z|agohover

corrigido. Obrigado pela sugestão sobre annotations, vou estudar o tema.

Bernardo de Padua 1223498899|%e %b %Y, %H:%M %Z|agohover

faltou a classe simulador para o lab 1.