Lab1 Cicero David

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

Introdução

Nessa prática, foi desenvolvido um conjunto de seis classes , descritas na parte de desenvolvimento, que representam entidades de um sistema contextualizado com uma organização de ensino, estebelecendo relações e implementando os conceitos de orientação à objetos.

Desenvolvimento

As classes foram desenvolvidas de acordo com as especificações contidas na instrução do laboratório. Foi utilizado o ambiente de desenvolvimento BlueJ. Abaixo segue uma descrição e o código-fonte de cada classe.

Aluno

Essa é uma classe abstrata que representa uma entidade aluno, que pode ser do tipo safo e preguiçoso ou esforçado. Assim, foi implementado o conteito de Herança para tratar dessa entidade. A classe Aluno é superclasse e as classes AlunoSafoPreguicoso e AlunoEsforcado são sub-classes. Como um aluno deve ser sempre safo e preguicoso ou esforçado a classe Aluno foi criada com o qualificador Abstract, para que não possa ser instanciada.
A classe contém basicamente variáveis de instancia, e seus getters, e um método para realizar entrega de relatório. Os metodos getInteligencia() e getDedicacao(), são criados para serem subescrevidos por métodos das sub-classes.

public abstract class Aluno
{
    private int conhecimento = 0;
    private String nome;
    private RelaQueue queue = new RelaQueue();
 
    public Aluno(String n, RelaQueue rel){
        this.nome = n;
        this.queue = rel;
    }
 
    public void fazEEntregaRelatorio(){
        Relatorio rela;
        rela = new Relatorio((2 * this.getDedicacao() + 1 * this.getInteligencia() ) / 3 , (1 * this.getDedicacao() + 2 * this.getInteligencia() ) / 3, this);
        queue.queue(rela);
        this.conhecimento++;
 
    }
 
    public abstract float getInteligencia();
    public abstract float getDedicacao();
 
    public int getConheciomento(){
 
        return this.conhecimento;
    }
 
    public String getNome(){
        return this.nome;
    }
}

AlunoEsforcado

Sub-classe da classe Aluno. São declarados mais dois atributos, que representam um valor para caracterizar a inteligência e a dedicação do aluno. Possui também os métodos para retornarem os valores desses atributos e um contructor que seta os atributos e chama o constructor da super-classe.

import java.util.*;
 
public class AlunoEsforcado extends Aluno
{
 
    private float inteligencia;
    private float dedicacao;
 
    public AlunoEsforcado(String nome, RelaQueue queue)
    {
        super(nome, queue);
        inteligencia = 0.5f;
        dedicacao = 1;
    }
 
    public float getInteligencia(){
        return this.inteligencia;
    }
 
    public float getDedicacao(){
        return this.dedicacao;    
    }
}

AlunoSafoPreguicoso

Semelhante ao AlunoEsforcado, entretanto não é criado o atributo que representa a dedicação do aluno. Nesse caso é criado um método que retorna um número aleatório para esse atributo.

import java.util.*;
 
public class AlunoSafoPreguicoso extends Aluno
{
 
    private float inteligencia;
 
    public AlunoSafoPreguicoso(String nome, RelaQueue queue)
    {
        super(nome, queue);
        inteligencia = 1;
    }
 
    public float getInteligencia(){
        return this.inteligencia;
    }
 
    public float getDedicacao(){
        Random generator  = new Random();
        float r = generator.nextFloat();
        return r*(0.5f);
    }
}

Relatorio

Classe que implementa a entidade relatório que é feito pelos alunos e corrigido pelos professores. A classe contém atributos que quantificam a qualidade e a originalidade do relatório e o aluno que o realizou. Os métodos são somente o getters dos atributos.

public class Relatorio
{
 
    private float qualidade;
    private float originalidade;
    private Aluno aluno;
 
    public Relatorio(float qual, float orig, Aluno al)
    {
        this.qualidade = qual;
        this.originalidade = orig;
        this.aluno = al;
    }
 
    public float getQualidade(){
        return this.qualidade;
    }
 
    public float getOriginalidade(){
        return this.originalidade;
    }
    public Aluno getAluno(){
        return this.aluno;
    }
 
}

RelaQueue

Classe que implementa um fila de relatórios para ser corrigida pelos professores. A classe não possui atributos de instância, somente variaveis internas incessíveis à objetos de outra classe. Os dois métodos consiste basicamente em retirar o adicionar relatório à fila.

public class RelaQueue
{
 
    private Relatorio[] array  = new Relatorio[10];
    private Relatorio valor;
    private int fim = 0;    
    private int inicio = 0;
 
public void queue (Relatorio rela)
{
    array[fim] = rela;
    fim = (fim+1)%10;
}
 
public Relatorio dequeue()
{
    if (inicio != fim){
    valor = array[inicio];
    inicio = (inicio+1)%10;
    return valor;
    }
    else return null;
}
 
}

Professort

Classe que implementa a entidade professor que tem como única função corrigir relatórios, definido a nota de cada um. Possui como único atributo uma fila de relatórios. Foram implementados dois métodos, um privado que realiza o correção de um relatório, definindo a nota, e ou public que faz com que o profesor corrija todos os relatórios.

import java.util.*;
 
public class Professor
{
 
    RelaQueue queue;
 
    public Professor(RelaQueue q)
    {
       queue = q;
    }
 
    private float corrigirRelatorio(Relatorio rela){
        Random r = new Random();
        double nota = ( rela.getQualidade() + rela.getOriginalidade() + r.nextFloat() ) / 3 * 10;
 
        return (float)nota;
 
    }
 
    public void corrigirRelatorios(){
 
        Relatorio rela;
        do{
            rela = queue.dequeue();
            if (rela!=null)
            System.out.println(rela.getAluno().getNome() + ": " + corrigirRelatorio(rela));
 
    }
    while (rela!=null);
 
}
}

Resultados

Após a compilação efetiva do projeto, depois de corrigir alguns erros, obtivemos o diagrama de classes obtido no BlueJ.

No digrama foi possível vizualizar as relações de herança e composição, bem como a instanciação de uma classe de um objeto por outro de outra classe.
Por último, foi ralizado o teste com JUnit com código sugerido na instrução do lab. Obtivemos então o resultado satisfatório mostrado abaixo:

Conclusão

O lab foi útil para aprender como implementar herença e composição e se familiarizar mais com a linguagem. A utilização do BlueJ é interessante em virtude da interface gráfica que gera o diagrama de classes, entretanto para o programador é um ambiente bastante ineficiente quando comparado com IDEs como NetBeans e Eclipse.

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

Só um pequeno detalhe, o fato de vc ter usado do{}while() faz com que o professor tente corrigir se a queue estiver inicialmente vazia (e vai gerar um null pointer exception). Faltaram testes manuais, mas o rela está bom.

Quanto ao Eclipse/Netbeans, o que se ganha em "eficiência" é a possibilidade de autocomplete, refatorações e criação de UI (user interface). Mas este lab não justificava nenhuma destas funcionalidades e a complexidade adicional confunde iniciantes. O BlueJ obriga o aluno a pensar em tudo em termos de classes e objetos (por possibilitar que vc instancie classes manualmente e vá executando-as passo a passo).

Estas IDEs acabam escondendo muitas coisas do usuário (como a própria ineficiência/burocracia de Java). Ex.: pode-se criar uma interface sem saber quase nada a respeito das bibliotecas de UI do Java. Isto é ruim no ponto de vista de aprendizagem, principalmente para a gente (não queremos ensinar a mexer na IDE, e sim os conceitos de OO). Portanto, o importante primeiro é aprender, depois buscar eficiência.

Sugiro que vc use estas IDEs no seu dia a dia, mas não se prenda a elas. Pode ser igual a dirigir um avião no piloto automático e achar que sabe o que está fazendo (e um dia vc tem que desligá-lo).