Lab1 Maykon Bergamaschi

aluno: Maykon Lorencini Bergamaschi
ano/sem: 2008/2o.
data do laboratório (num. da semana) : 06/08/2008 (2)

Introdução

Neste laboratório, foram aplicados os primeiros conceitos relacionados a Java ensinados em sala de aula. Para tal, foi simulada a entrega de relatórios de alunos a um professor: os trabalhos entram em uma fila e a correção é feita pelo professor na ordem em que a entrega foi feita. Como será visto adiante, foram criadas seis classes para a realização da tarefa.

Desenvolvimento

1- Classes

Serão descritas a seguir as classes desenvolvidas neste laboratório. Nas descrições que serão realizadas, o enfoque não será explicitar o que cada variável armazena ou o que cada método realiza. Será destacado o que realmente importa, os conceitos aplicados na criação das classes.

1.1- Classe abstrata Aluno

public abstract class Aluno
{
    int conhecimento = 0;
    String nome = new String();
    RelaQueue queue;
 
    /**
     * Constructor for objects of class Aluno
     */
    public Aluno(String nome , RelaQueue queue)
    {
        this.nome = nome;
        this.queue = queue;
    }
 
    //cria um objeto Relatorio e o repassa ao método queue do objeto queue da classe RelaQueue
    public void fazEEntregaRelatorio()
    {
        double qualidade = (2 * this.getDedicacao() + 1 * this.getInteligencia() ) / 3 ;
        double originalidade = (1 * this.getDedicacao() + 2 * this.getInteligencia() ) / 3 ;       
        Relatorio rela = new Relatorio (qualidade, originalidade, this);
        queue.queue(rela); //emprego do conceito de mensagem
        this.conhecimento = this.conhecimento + 1; //conhecimento aumenta após entregar o relatório
    }
 
    public int getConhecimento(){
        return conhecimento;    
    }
 
    public abstract double getDedicacao();
    public abstract double getInteligencia();     
 
    public String getNome() {
        return nome;
    }
 
}

Na classe Aluno, foram empregados os conceitos de mensagem, pois é feita a solicitação a um objeto a execução de um de seus métodos. Por se tratar de uma classe abstrata, o uso de outras classes como AlunoSafoPreguicoso e AlunoEsforcado configuram a herança de classes, porém isso será discutido de modo mais pormenorizado adiante.

1.2- Classe AlunoSafoPreguicoso

import java.util.*; //para gerar os números pseudo-aleatórios
 
public class AlunoSafoPreguicoso extends Aluno
{
    double inteligencia = 1.0;
 
    /**
     * Constructor for objects of class AlunoEsforcado
     */
    public AlunoSafoPreguicoso(String nome, RelaQueue queue)
    {
 
        super(nome,queue); //uso do conceito de herança de classes
    } 
        public double getInteligencia()
        {
            return inteligencia;   
        }
 
        public double getDedicacao()
        {
            return generateRandomDe0aMeio();   
        }             
 
     /**
     * Um método público que gera números aleatórios
     */
    //extraído do exemplo "classe louca"
    public double generateRandomDe0aMeio()
    {
        Random generator = new Random();
        double r = generator.nextDouble();
        return r * 0.5;
    }    
}

Na classe AlunoSafoPreguicoso, foi empregado o conceito de herança de classes. AlunoSafoPreguicoso, subclasse de Aluno, herdou características como nome e fila de entrega de relatórios. Foi necessário definir métodos como getInteligencia() e getDedicacao(), abstratos na classe Aluno.

Objetos da classe AlunoSafoPreguicoso podem ser tratados da mesma forma que os da classe Aluno, ou seja, há um polimorfismo.

1.3- Classe AlunoEsforcado

public class AlunoEsforcado extends Aluno
{
    double inteligencia = 0.5;
    double dedicacao = 1.0;
 
    /**
     * Constructor for objects of class AlunoEsforcado
     */
    public AlunoEsforcado(String nome, RelaQueue queue)
    {
 
        super(nome,queue); //uso do conceito de herança de classes
    } 
        public double getInteligencia()
        {
            return inteligencia;   
        }
 
        public double getDedicacao()
        {
            return dedicacao;   
        }             
}

Novamente, na classe AlunoEsforcado, foi utilizado o conceito de herança de classes. AlunoEsforcado, da mesma forma que AlunoSafoPreguicoso, herdou características da classe Aluno como nome e fila de entrega de relatórios. Métodos como getInteligencia() e getDedicacao(), abstratos na classe Aluno, foram definidos.

Objetos da classe AlunoEsforcado podem ser tratados da forma semelhante aos da classe Aluno. Portanto, novamente existe um polimorfismo com o uso dessa classe.

1.4- Classe Relatorio

public class Relatorio
{
    double qualidade; 
    double originalidade;  
    Aluno aluno;
 
    /**
     * Constructor for objects of class Relatorio
     */
    public Relatorio(double qualidade, double originalidade, Aluno aluno)
    {
        this.qualidade = qualidade;
        this.originalidade = originalidade;
        this.aluno = aluno;       
    }
 
    public Aluno getAluno(){
        return this.aluno;
    }
 
    public double getQualidade(){
        return this.qualidade;
    }
 
    public double getOriginalidade(){
        return this.originalidade;
    }    
 
}

Trata-se de uma classe mais simples que as demais. Os objetos dessa classe constituirão a fila de relatórios para o professor corrigir.

1.5- Classe RelaQueue

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

É também uma classe mais simples. Objetos da classe RelaQueue são as fila de relatórios citadas na descrição da classe Relatorio.

1.6- Classe Professor

import java.util.*; //para a geração de pseudo-aleatórios
public class Professor
{
 
    RelaQueue queue;
 
    /**
     * Constructor for objects of class Professor
     */
    public Professor(RelaQueue queue)
    {
        this.queue = queue;
    }
 
        /**
     * Um método público que gera números aleatórios
     */
    //adaptado do exemplo "classe louca"
    public double fatorAleatorioDe0a1()
    {
        Random generator = new Random();
        double r = generator.nextDouble();
        return r;
    }    
 
    private double corrigeRelatorio(Relatorio rela)
    {
        double nota = 10*( rela.getQualidade() + rela.getOriginalidade() + this.fatorAleatorioDe0a1()) / 3; //mensagem
        return nota;
    }
 
    public void corrigirRelatorios(){
 
        Relatorio rela = queue.dequeue();       //mensagem
 
        while (rela!=null) {
            System.out.println(rela.getAluno().getNome()+" : "+this.corrigeRelatorio(rela));       //mensagem
            rela = queue.dequeue();
        }
    }
}

Na classe Professor, observou-se o uso do conceito de mensagem, visto que foram solicitados a objetos (como queue, da classe RelaQueue) a execução de seus métodos (dequeue e queue). getOriginalidade() e getQualidade(), métodos da classe Relatorio, tiveram também sua execução solicitada pela classe Professor.

2- Diagrama de classes compiladas

lab1_img1_DiagramaClasses.PNG

A imagem acima inclui a classe de testes testAluno, cujo código corresponde ao fornecido no roteiro. No item seguinte, os resultados obtidos com a execução da classe.

3- Resultado dos testes

lab1_img2_Testes.PNG

O output do programa obtido foi o esperado, uma vez que na classe de testes houve o "roubo" dos roteiros deixados na fila.

Os arquivos com os códigos construídos neste laboratório estão anexados a esta página, inclusive a classe de testes testAluno.

Conclusão

Os conceitos vistos neste laboratório são introdutórios no aprendizado da programação orientada a objeto. É muito importante a fixação dos conceitos abordados, como herança de classes, polimorfismo e mensagem, uma vez que são utilizados freqüentemente na orientação a objeto. Vale ressaltar que este laboratório foi importante para a fixação desses conceitos.

Alguns alunos tiveram facilidade para fazer esta atividade. Entretanto, há muitos alunos que nunca tinham tido qualquer contato com programação orientada a objeto. Esta atividade foi, para eles, de elevada complexidade. Ou seja, há um grande desnível entre os alunos da turma. Pede-se a atenção dos professores a esse fato na elaboração das próximas atividades.

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