Lab1 Rafael Siqueira

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

Introdução

Nesse primeiro laboratório, o objetivo era realizar um primeiro contato com um novo tipo de programação, a qual é o assunto do curso, a programação orientada a objetos (OO). Para isso, foi elaborado um programa simples mas que envolvesse conceitos importantes que devem ser segmentados para um bom aproveitamento dessa programação tão usada hoje em dia. O programa simula a realização de relatórios por alunos, os quais (relatórios) são colocadas numa fila, da qual são tirados pelo professor que os corrige e dá uma nota baseada na originalidade e qualidade do relatório, características essas que são dependentes da dedicação e da inteligência de cada aluno. Para testar o programa, foi fornecido um código pronto que realiza os testes.

Desenvolvimento

De acordo com o diagrama apresentado na instrução do laboratório, foram criadas e usadas 6 classes, além da classe de testes fornecida pela professor: Aluno, AlunoSafoPreguicoso, AlunoEsforcado, Relatorio, Professor e RelaQueue.

A classe Aluno utilizada é uma classe abstrata, ou seja, que não pode ter instâncias próprias, apenas serve de superclasse para outras duas: as classes AlunoSafoPreguicoso e AlunoEsforcado. Dessa forma, usou-se o conceito de herança e de polimorfismo para aproveitamento de código e para explorar os recursos novos de Java.

Aluno

public abstract class Aluno
{
    //Variáveis internas e estado inicial de conhecimento
    private int conhecimento = 0;
    private String nome = new String();
    private RelaQueue queue;
 
    //Construtor
    public Aluno(String nome,RelaQueue queue) {
        this.nome=nome;
        this.queue=queue;
    }
 
    //Getter de nome
    public String getNome() {
        return this.nome;
    }
 
    //Método que faz um novo relatório e coloca-o na fila de relatórios, além de incrementar o conhecimento do aluno
    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);
        conhecimento++;
    }
 
    //Métodos abstratos que são definidos de maneiras distintas em cada subclasse
    abstract double getDedicacao();
    abstract double getInteligencia();
 
    //Getter de conhecimento
    public double getConhecimento() {
        return this.conhecimento; 
    }
}

As classes seguintes, AlunoSafoPreguicoso e AlunoEsforcado, são subclasses de Aluno e dessa forma, herdam todos os métodos de Aluno podendo ter métodos próprios. Essa herança fica evidente ao se exigir que o construtor dessas classes tenha a linha 'super()'.

AlunoSafoPreguicoso

import java.util.*; //Importa biblioteca de Java para utilização de alguma de suas classes pré-definidas
 
//Essa classe é subclasses de Aluno
public class AlunoSafoPreguicoso extends Aluno
{
    //Variáveis internas
    private double inteligencia = 1;
    private double dedicacao;
 
    //Construtor
    public AlunoSafoPreguicoso(String nome,RelaQueue queue) 
    {
        super(nome,queue);
    }
 
    //Getter de inteligencia
    public double getInteligencia()
    {
        return this.inteligencia;
    }
 
    //Getter de dedicacao
    public double getDedicacao() 
    {
        Random generator = new Random();
        double r = generator.nextDouble();
        return r * 0.5;   
    }
}

AlunoEsforcado

//Essa classe é uma subclasse de Aluno
public class AlunoEsforcado extends Aluno
{
    //Variáveis internas
    private double inteligencia = 0.5;
    private double dedicacao = 1;
 
    //Construtor
    public AlunoEsforcado(String nome,RelaQueue queue) 
    {
        super(nome,queue);
    }
 
    //Getter de inteligencia
    public double getInteligencia() 
    {
        return this.inteligencia;
    }
 
    //Getter de dedicacao
    public double getDedicacao() 
    {
        return this.dedicacao;
    }  
}

A classe RelaQueue é de extrema importância pois é ela que liga os dois extremos do trabalho (alunos e professor) e é assim referenciada em todas as classes. Ela implementa uma fila simples (FIFO) que é cíclica e portanto, ao estourar funciona como se estivesse vazia.

RelaQueue

public class RelaQueue
{
    //Estado inicial - fila vazia
    private Relatorio[] array = new Relatorio[10];
    private int inicio = 0;
    private int fim = 0;
 
    //Comportamento
    //Método que coloca um relatório na fila
    public void queue (Relatorio rela) 
    {
        array[fim] = rela;
        fim = (fim+1) % 10;
    }
 
    //Método que retorna um relatório tirando-o da fila, retornando nulo caso a mesma esteja vazia
    public Relatorio dequeue()
    {
        if (inicio==fim)
        {
            return null;
        }
        else 
        {
            Relatorio relasaida = array[inicio];
            inicio = (inicio+1) % 10;
            return relasaida;
        }
    }
}

A classe Relatorio é bastante simples, tendo somente o seu construtor e seus getters. Ela é instanciada dentro da classe Aluno no método fazEEntregaRelatorio().

Relatorio

public class Relatorio
{
    //Variáveis internas
    private double qualidade;
    private double originalidade;
    private Aluno aluno;
 
    //Construtor
    public Relatorio(double qualidade,double originalidade,Aluno aluno) {
        this.qualidade = qualidade;
        this.originalidade = originalidade;
        this.aluno = aluno;
    }
 
    //Getter de qualidade
    public double getQualidade() {
        return this.qualidade;
    }
 
    //Getter de originalidade
    public double getOriginalidade() {
        return this.originalidade;
    }
 
    //Getter de aluno
    public Aluno getAluno() {
        return this.aluno;
    }
}

A classe Professor também tem acesso à fila de relatórios, tirando eles da fila, corrigindo-os e divulgando (imprimindo) suas notas.

Professor

import java.util.*; //Importa biblioteca de Java para que se utilize alguma de suas classes pré-definidas
 
public class Professor
{
    //Variáveis internas
    RelaQueue queue;
 
    //Contrutor
    public Professor(RelaQueue queue) {
        this.queue=queue;
    }
 
    //Corrige um relatorio e retorna a nota do aluno no mesmo
    private double corrigirRelatorio(Relatorio rela) 
    {
        double nota =(rela.getOriginalidade()+rela.getQualidade()+fatorAleatorioDe0a1())/3*10;
        return nota;
    }
 
    //Retorna um número aleatório de 0 a 1
    public double fatorAleatorioDe0a1()
    {
        Random generator = new Random();
        double r = generator.nextDouble();
        return r * 1;
    }
 
    //Método que faz com que todos os relatórios sejam tirados da fila, sejam corrigidos e tenham suas notas impressas na tela
    public void corrigirRelatorios() 
    {
        Relatorio rela = queue.dequeue();
        while (rela!=null) 
        {
            System.out.println(rela.getAluno().getNome()+": "+corrigirRelatorio(rela));   
            rela=queue.dequeue();
        }
    }   
}

A seguir seguem print-screens mostrando o bom funcionamento do programa

imagem1.JPG

Imagem 1 - Classes criadas e compiladas

imagem2.JPG

Imagem 2 - Realização dos testes e exibição dos resultados usando o objeto teste

O teste manual foi feito da seguinte forma: primeiramente foi criado um objeto da classe RelaQueue, depois dois alunos, um da subclasse AlunoEsforcado e um da subclasse AlunoSafoPreguicoso e por fim um objeto da classe Professor. Após a instanciação dos objetos, criou-se dois relatórios, um de cada aluno, através do método fazEEntregaRelatorio() de cada aluno criado. Em seguida, acessou-se o método corrigirRelatorios() do objeto Professor e assim as notas de cada aluno foram impressas na tela.

imagem3.JPG

Imagem 3 - Objetos instanciados manualmente e exibição dos resultados do teste manual

Conclusão

O laboratório proposto atendeu bem aos objetivos que possuía, afinal, os principais conceitos da programação e da linguagem foram absorvidos, porém houve ligeira resistência para compreender as novas idéias que a OO propõe. A simplicidade desse laboratório foi essencial para um bom aprendizado de tantas novidades, como a criação e utilização de classes, com referências de uma às outras. Em especial, um conceito que demorei a entender foi o de construtor, que nada mas faz do que dar valores inicias às variáveis internas de um objeto quando esse é criado. Sobre o curso, a primeira impressão foi muito boa, os slides estão bem feitos porém o primeiro laboratório foi muito desorganizado, uma verdadeira bagunça. Tudo ficou meio jogado e o aproveitamento dele foi quase nulo. Não digo que deve-se dar um código mastigado linha por linha para ambientar a turma, mas uma prosposta para ser feita na hora do laboratório de uma classe simples tem muito mais efeito que um exemplo dado num slide numa aula.

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