Lab1 Fabio Imada

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

Introdução

Foi criado um programa que utiliza alguns conceitos de programação OO. Foram utilizados, por exemplo, hierarquia de classes e sobre-escrita de métodos, bem como os objetos em si e sua interação para obter o resultado desejado.
Para checar a funcionalidade do programa foi criado uma unidade de teste do programa BlueJ.

Desenvolvimento

O programa foi criado com base em seis classes:
- Aluno (super classe dos outros tipos de alunos)
> AlunoSafoPreguicoso (sub-classe de aluno)
> AlunoEsforcado (sub-classe de aluno)
- Professor
- Relatorio
- RelaQueue

Seguem os seus respectivos códigos:

Aluno:

public abstract class Aluno //Classe abstrata não pode ser instanciada diretamente, ela precisa ter uma sub-classe 
//não abstrata para isso. Public significa que a classe pode ser acessada por "qualquer um"
{
    private int conhecimento = 0; // Cada classe possui algumas variáveis internas que são colocadas como private
//pois só há necessidade de acessá-las dentro da classe
    private String nome = new String();
    private RelaQueue queue = new RelaQueue();
 
    public Aluno(String nome,RelaQueue queue) // o construtor é não possui a classe declarada por ser a da classe 
//e é responsável por criar a instância da classe Aluno.
    {
        this.nome = nome; // this.nome aponta para a variável interna da classe e a diferencia de nome, que se 
//refere ao parâmetro passado para utilizar o método.
        this.queue = queue;
    }
 
    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); // Aqui há a primeira interação entre os objetos do programa: o método de Aluno chama o
//método de RelaQueue que tem como parâmetro um Relatorio.
        this.conhecimento ++;
    }
 
    public abstract double getInteligencia(); // um método abstrato deve ser sobre-escrito por uma outra classe que 
//extende a classe atual(que passa a ser abstrata)
 
    public abstract double getDedicacao();
 
    public int getConhecimento()
    {
        return this.conhecimento;
    }
 
    public String getNome()
    {
        return this.nome;
    }
}

> AlunoSafoPreguicoso

import java.util.*;//Biblioteca importada para utilizar o método Random
public class AlunoSafoPreguicoso extends Aluno //extends indica que a classe criada é uma sub-classe de Aluno
{    
 
    public AlunoSafoPreguicoso(String nome,RelaQueue queue)
    {    
        super(nome,queue); // Aqui se utiliza o construtor da super-classe.
    }
 
    public double getInteligencia()
    {
        return 1;
    }
 
    public double getDedicacao()
    {
        Random generator = new Random();
        double r = generator.nextDouble();
        return r*0.5;
    }
}

> AlunoEsforcado

public class AlunoEsforcado extends Aluno
{
    public AlunoEsforcado(String nome,RelaQueue queue)
    {
        super(nome,queue);
    }
    public double getInteligencia()
    {
        return 0.5;
    }
    public double getDedicacao()
    {
        return 1;
    }
}

Professor

import java.util.*;
 
public class Professor
{
    private RelaQueue queue;
 
    public Professor(RelaQueue rela)
    {
        this.queue = rela;
    }
 
    private double corrigeRelatorio(Relatorio rela)
    {
        Random generate = new Random();
        double fatorAleatorioDe0a1 = generate.nextDouble();
        double nota = ( rela.getQualidade() + rela.getOriginalidade() + fatorAleatorioDe0a1 ) / 3 * 10;
        return nota;
    }
 
    public void corrigirRelatorios(){
        Relatorio rela;
        for ( rela = queue.dequeue(); rela != null ; rela=queue.dequeue() ){
            System.out.println(rela.getAluno().getNome() + ": " + corrigeRelatorio(rela)); // O método chama 
//System.out.println() que, no caso, imprime as notas dos alunos nos relas que estavam na fila.
        }
    }   
}

Relatorio

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

RelaQueue

public class RelaQueue
{
 
    private Relatorio[] array;
    private int inicio;
    private int fim;
 
    public RelaQueue()
    {
        //estado inicial:
        this.array = new Relatorio[10];
        this.inicio = 0;
        this.fim = 0;
    }
 
    public void queue(Relatorio rela)
    {
        array[fim] = rela;
        fim = (fim + 1) % 10;
    }
 
    public Relatorio dequeue(){
        Relatorio rela;
        if(inicio==fim)return null;
        else
        {
            rela = array[inicio];
            inicio = (inicio + 1) % 10;
            return rela;
        }
    }
}

Imagens

Diagrama de classes do BlueJ

Diagrama.jpg

Instâncias criadas

Instancias.jpg

Fila de relatorios após rodar métodos de Alunos instanciados

Fila.jpg

Saída no terminal após corrigir fila de relatórios

Saida1.jpg

Execução do Teste

Teste.jpg

Saída do teste no Terminal

Teste_out.jpg

Conclusão

O lab foi simples e o programa escolhido também, no entanto utilizou de forma clara alguns dos conceitos apresentados em aula. Foi uma boa forma de abordar uma linguagem completamente desconhecida sem deixar de introduzir a implementação de conceitos básicos da Orientação a Objetos.
Na minha opinião, seria interessante iniciar o curso com este lab durante as aulas das duas primeiras semanas, desenvolvendo o lab ou a ClasseLouca aos poucos ao mesmo tempo que se apresentam alguns conceitos, assim os alunos participariam mais ativamente das aulas iniciais, que foram difíceis de absorver por conterem códigos em linguagens desconhecidas e pelo fato de muitos não conhecerem/compreenderem a definição de "objetos". Pelo menos para mim, a realização do lab contribuiu muito para o entendimento de conceitos básicos como a diferença de classes e instâncias!
Arquivo .zip do Lab01

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