Lab1 Anderson Aiziro

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

Introdução

Neste laborátorio, tivemos o primeiro contato com a linguagem Java e seus principais conceitos. Utilizamos como projeto base um sistema de entrega e correção de relatórios para trabalhar com conceitos da orientação a objetos vistos em sala de aula. Os alunos, safos ou esforçados, criam relatórios e os entregam para um professor. Estes relatórios são enfileirados em uma fila(queue) circular. O professor tem acesso a essa fila na ordem de adição dos relatórios na fila e é responsável por corrigir e mostrar as notas que os alunos obtiveram.
O projeto possui 6 classes, sendo elas: Aluno, AlunoSafoPreguicoso, AlunoEsforcado, Relatorio, RelaQueue e Professor. Os códigos e as funcionalidades de cada classe são detalhados abaixo.

Desenvolvimento

A primeira classe criada é a classe abstrata Aluno. A classe é abstrata pois alguns de seus métodos serão sobrescritos nas subclasses de AlunoEsforcado e AlunoSafoPreguicoso.

abstract class Aluno {
 
    int conhecimento=0;
    String nome = new String();
    RelaQueue queue = new RelaQueue();
 
    //construtor de Aluno
    public Aluno(String nome, RelaQueue queue){
        this.nome=nome;
        this.queue=queue;
    }
    //a cada relatório feito, o conhecimento aumenta em 1    
    public void getConhecimento(){
        this.conhecimento++;
    }
 
    public String getNome(){
        return this.nome;
    }
 
    //cada relatório possui como atributos, a qualidade e a originalidade, que dependem do tipo do aluno
    public void fazEEntregaRelatorio(){
        Relatorio rela = new Relatorio (getQualidade(),getOriginalidade(), this);
        queue.queue(rela);
        getConhecimento();
    }    
 
    //cálculo da qualidade do projeto
    double getQualidade(){
        double qualidade=(2*this.getDedicacao()+ this.getInteligencia() )/3;
        return qualidade;
    }
 
    //cálculo da originalidade do projeto
    double getOriginalidade(){
        double originalidade= (this.getDedicacao()+ 2*this.getInteligencia())/3;
        return originalidade;
    }
 
    //metodos abstratos que serão sobrescritos nas subclasses
    abstract double getInteligencia();
    abstract double getDedicacao();
}

Como subclasses de Aluno, temos AlunoEsforcado e o AlunoSafoPreguicoso, como apresentados abaixo. Nestas subclasses utilizamos o conceito de hierarquia e introduzimos o comando super(nome,queue) para chamar o construtor da super-classe ( classe Aluno).

public class AlunoEsforcado extends Aluno{
    double inteligencia=0.5;
    double dedicacao=1;
 
    //construtor que chama a super-classe Aluno
    public AlunoEsforcado(String nome, RelaQueue queue){
        super(nome,queue);
    }
 
    //métodos que retornam a inteligência e a dedicação do aluno
    double getInteligencia(){
        return this.inteligencia;
    }
    double getDedicacao(){
        return this.dedicacao;
    }
}
import java.util.*; //biblioteca inserida para habilitar o uso da função Random()
 
public class AlunoSafoPreguicoso extends Aluno
{
double inteligencia=1;
    double dedicacao;
 
    //construtor que chama a super classe aluno
    public AlunoSafoPreguicoso(String nome, RelaQueue queue){
        super(nome,queue);
    }
        //metodos que retornam a inteligência e a dedicação dos alunos
    double getInteligencia(){
        return this.inteligencia;
    }
    double getDedicacao(){
        return generateRandomDe0aMeio();
    }
 
    public double generateRandomDe0aMeio()
    {
        Random generator = new Random();
        double r = generator.nextDouble();
        return r * 0.5;
    }
}

Agora, temos a classe Relatorio. Cada relatório possui uma qualidade e uma originalidade dependendo da característica do aluno.

public class Relatorio{
 
    double originalidade;
    double qualidade;
    Aluno aluno;
        // cada relatorio possui um aluno (que fez o relatorio), uma qualidade e uma originalidade
    public Relatorio(double qualidade,double originalidade,Aluno aluno){
        this.originalidade=originalidade; 
        this.qualidade=qualidade;
        this.aluno=aluno;
    }
 
    double getQualidade(){
        this.qualidade=(2*this.aluno.getDedicacao()+ this.aluno.getInteligencia() )/3;
        return this.qualidade;
    }
 
    double getOriginalidade(){
        this.originalidade= (this.aluno.getDedicacao()+ 2*this.aluno.getInteligencia())/3;
        return this.originalidade;
    }
 
    Aluno getAluno(){
        return this.aluno;
    }
}

Agora, temos a classe Relaqueue. Em RelaQueue temos a fila de relatórios entregues ao professor. Por isto, RelaQueue deve ser acessível tanto para o professor quanto para os alunos. Os alunos adicionam relatórios na fila para que possam ser corrigidos e o professor retira os relatórios, na ordem de adição, para corrigí-los.

public class RelaQueue
{
 
    Relatorio[] array = new Relatorio[10];
    int inicio = 0;
    int fim = 0;
      //adiciona um relatorio ao final da fila
    public void queue(Relatorio elem){
      array[fim] = elem;
      fim = (fim + 1) % 10;
    }
    //retira um relatório da lista
    public Relatorio dequeue(){
      Relatorio valor = array[inicio];
 
      if(inicio==fim){ //quando o ponteiro para o início apontar para o mesmo local que o final, a fila está vazia
          valor=null;
      }
      inicio = (inicio + 1) % 10;
      return valor;
    }
}

Finalmente, temos a classe Professor. O professor terá um método privado corrigeRelatorio, isto significa que este método é acessível somente da classe Professor. Neste método, recebe-se como parâmetro um relatório e retorna-se a nota do relatório.

import java.util.*;
 
public class Professor
{
 RelaQueue queue = new RelaQueue();
    Relatorio rela;
 
    public Professor(RelaQueue queue){
        this.queue=queue;
    }
 
    private double corrigirRelatorio(Relatorio rela){
        double r = fatorAleatoriode0a1();
        return ((rela.aluno.getOriginalidade()+rela.aluno.getQualidade()+r)/3)*10; 
    }
 
    private double fatorAleatoriode0a1(){
       Random generator = new Random();
        double r = generator.nextDouble();
        return r ;
    }
        //método em que o professor retira um relatório da fila e o corrige. Imprimindo o nome do aluno e sua nota
    public void corrigirRelatorios(){
        while(true){
            rela=queue.dequeue();
            if(rela==null) break;
            System.out.print(rela.aluno.nome+": ");
            System.out.println(corrigirRelatorio(rela));
 
        }
    }
 
}

Para testar o bom funcionamento do programa, iremos testar manualmente os objetos e em seguida utilizaremos a classe de teste criada nas instruções do laboratório para testar o programa.

Agora, vamos realizar o teste manual dos objetos. Inicialmente, vamos criar 4 alunos:
alunos.JPG

Resultado do código acima:

alunosimprime.JPG

Após a criação dos alunos, cada um deles vai fazer e entregar o relatório. Em seguida, o professor irá corrigir os 4 relatórios criados. O código que descreve as operações acima é o seguinte:

criarelatorio.JPG

Como resultado do código acima, temos:

resultadorelatorio.JPG

Após o teste manual dos objetos, vamos utilizar a classe de testes nas instruções para mostrar o funcionamento do programa.

Inicialmente, vamos mostrar o diagrama de classes do projeto:

diagramaclasses.JPG

Com o diagrama de classes acima, vamos compilá-lo e utilizar a opção "Test all" da classe de teste. O resultado obtido é o seguinte:

diagramaclassescompilado.JPG

O resultado obtido com a classe de testes é o seguinte:

diagramaclassesresultado.JPG

Conclusão

Este primeiro projeto envolveu o aprendizado da sintaxe da linguagem Java e a aplicação de conceitos de orientação a objetos vistos em aula. Como muitos alunos não conheciam a liguagem Java e nas matérias de programação anteriores, trabalhamos com linguagens procedurais (C), tratar as particularidades de orientação a objetos ao mesmo tempo da inexperiência com a linguagem Java, tornou o projeto muito difícil. Assim, poderiam ser dedicadas algumas aulas para familiarizar os alunos com a sintaxe de Java e seus comandos básicos antes de aplicá-los em projetos. Desse modo, os projetos seriam uma forma de trabalhar os conceitos de orientação a objetos sem criar problemas adicionais por causa da sintaxe.

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