Lab 1 - Introdução a OO e Java

Objetivo

Este laboratório irá introduzir o ambiente de desenvolvimento Java que utilizaremos, o BlueJ, voltado para o ensino de orientação a objetos. Além disto, iremos aplicar os conhecimentos adquiridos nas primeiras aulas, fazendo uma primeira aplicação orientada a objetos em Java.

Desenvolvimento

1 - Instale o BlueJ

  • Site do BlueJ
    • É necessário instalar antes o J2SE (kit de desenvolvimento de java da Sun) - Baixe o JDK 6 Update 7
    • Os professores terão um CD com os dois.

2 - Aprendendo Java em 30 segundos

Exemplo de uma classe em Java (que tem tudo que vocês vão precisar):

import java.util.*;  //faz com que Classes do pacote java.util 
                    //possam ser chamadas diretamente
                    //pacotes são coleções de classes da API de Java
 
//Definindo uma classe que extende Vector (uma lista ordenada)
public class ClasseLouca extends Vector
{
    // declare as variáveis internas aqui
    private int x; //private antes de int indica que a variável é privada
 
    private int y = 10; //vc pode inicializar as variáveis diretamente
 
    //um array de inteiros - inteiro é um tipo nativo, por isto
    // começa com minúscula
    private int[] array = new int[10]; //máximo de 10 elementos
 
    //um array de Strings - String é um objeto (que possui classe, etc)
    private String[] stArray = new String[10];
 
    /**
     * Construtor: chamado quando vc cria um objeto. Pode ter parâmetros
     * assim como um método qualquer, só que não tem valor de retorno.
     */
    public ClasseLouca(int valorX)
    {
        // ou você pode inicializar as variáveis no construtor
        this.x = valorX; //this quer dizer "este objeto"
                        //muitas vezes é opcional, mas
                        //ajuda a deixar claro quando vc
                        //está usando uma variável local (que morre com 
                        //no fim do método) ou uma variável de instancia
    }
 
    /**
     * Um método público que gera números aleatórios
     */
    public double generateRandomDe0aMeio()
    {
        Random generator = new Random();
        double r = generator.nextDouble();
        return r * 0.5;
    }
 
    /*
     * um método privado (e feliz) que imprime algo (mas não retorna nada)
     */
    public void happyMethod()
    {
        // as estruturas de controle (if, while, etc)
        //e os operadores são praticamente identicos aos de C
        if(x > 5) {
            //como imprimir algo, com quebra de linha no final
            System.out.println("I am happy!");
        } else {
            System.out.println("I am sad");
        }
    }
 
    //Adiciona adiciona elementos a posições dos dois arrays
    public void addsToArray(int i, String s)
    {
        array[4] = i;
        stArray[6] = s;
    }
 
    //retorna um elemento qualquer do stArray
    public String getStArray(int index)
    {
        return stArray[index];
    }
 
    //diz se um elemento de stArray é nulo (null)
    public boolean oQueENull(int index)
    {
        return stArray[index] == null;
    }
 
    private int privateMethod()
    {
        return 10;
    }
}

Crie um projeto novo no BlueJ e entre o código desta classe. Crie um instância da classe e brinque de chamar seus métodos e verificar o conteúdo das variáveis internas da instância.

Você vai precisa também saber criar uma classe é métodos abstratos. Basta usar a keyword abstract:

public abstract class GraphicObject {
   // declare fields
   // declare non-abstract methods
   abstract void draw();
}

3 - Implemente a aplicação representada na seguinte descrição e diagrama de classes (aqui começa o lab!)

Nossa aplicação simulará a execução e entrega de relatórios (de laboratório) por alunos a um professor. A medida que os alunos terminam seus relatórios, vão colocando-os numa "Fila de Entrega" (pode ser a fresta da porta da sala do professor). O professor corrige os relatórios na ordem em que foram entregues a ele, divulgando a nota. Para ilustrar a herança de classes, implementaremos duas subclasses de alunos, com comportamentos ligeiramente diferentes.

lab1.png

Classe RelaQueue

RelaQueue é a fila de entrega de relatórios ao professor. Tanto os alunos quanto o professor devem saber onde está o objeto do tipo RelaQueue do nosso sistema, para que possam, respectivamente, depositar e retirar os relatórios. Portanto, devemos criar um RelaQueue primeiro e passá-lo aos objetos alunos e professor, a medida que forem criados. Só haverá um objeto deste tipo na nossa aplicação.

A implementação desta classe deve ser semelhante a mostrada em sala de aula. Ela pode ter uma capacidade máxima de 10 elementos. Não pode-se utilizar uma Queue pronta de Java.

Código do Queue de sala de aula (pseudo código dinámico):

classe Queue
  estado inicial:
    array = novo Array(10)
    inicio = 0
    fim = 0
  comportamento:
    queue(elem)
      array[fim] = elem
      fim = (fim + 1) % 10
    dequeue()
      valor = array[inicio]
      inicio = (inicio + 1) % 10
      retorna valor

Lembre-se que Java é estático, portanto você terá que declarar os tipos das variáveis e de retorno.

Seu RelaQueue precisará de uma funcionalidade extra: Quando a queue estiver vazia, uma chamada a dequeue() deverá retornar null. O professor precisará disto, para saber que não existem mais relatórios para corrigir (e ele pode ir para casa descansar).

Classe (abstrata) Aluno

Nesta aplicação, podemos criar dois tipos de alunos: os do tipo AlunoEsforcado e do tipo AlunoSafoPreguicoso. Cada aluno tem 4 atributos acessíveis externamente (representados pelos métodos getATRIBUTO ). Os métodos getInteligencia e getDedicacao são abstratos (devem ser obrigatoriamente sobrescritos na subclasse). O método getInteligencia de AlunoSafoPreguicoso deve retornar um double randômico de 0 a 0,5. Os demais retornam os valores das variáveis de estado correspondentes. Os métodos getDedicacao() e getInteligencia() retornam doubles de 0 a 1. conhecimento é um inteiro que começa com o valor 0 e é incrementado cada vez que o aluno faz um relatório. nome é um String qualquer.

Os alunos podem ser criados com os construtores:

AlunoEsforcado aluno1 = new AlunoEsforcado("Joao Silva", relaQueue);
AlunoSafoPreguicoso aluno2 = new AlunoSafoPreguicoso("Jose Fonseca", relaQueue);

Classe Relatorio

Cada aluno pode fazer e entregar um relatório, com o método fazEEntregaRelatorio. Este método deve criar um objeto do tipo Relatorio e repassá-lo ao método queue do objeto da classe RelaQueue.

Cada relatório possui uma qualidade (doubles de 0 a 1), uma originalidade (idem) e foi feito por um aluno (objeto do tipo Aluno)

Para criar um relatório, o objeto aluno deve utilizar o construtor da classe Relatório:

Relatorio rela = new Relatorio(0.8, 0.4, this);
//                                |     |     |_ referencia a si mesmo (aluno)
//                                |     |__originalidade
//                                |__qualidade

A qualidade com que o aluno produz seus relatórios depende da sua inteligência e dedicação:

double qualidade = (2 * this.getDedicacao() + 1 * this.getInteligencia() ) / 3 ;
double originalidade = (1 * this.getDedicacao() + 2 * this.getInteligencia() ) / 3 ;

Classe Professor

Nosso professor deve corrigir os relatórios, retirando-os da fila. Nosso professor terá um método privado corrigeRelatorio, que recebe como parâmetro um relatório e retorna a nota do mesmo, que é uma média da originalidade, qualidade e de um fator aleatório, normalizado na escala de 1 a 10:

double nota = ( rela.getQualidade() + rela.getOriginalidade() + fatorAleatorioDe0a1 ) / 3 * 10;

O professor só tem um método público, corrigeRelatorios, que corrige todos os relatórios da fila e imprime suas notas. Por exemplo, ao corrigir 3 relatório, de Joao, Maria e Jose, ele imprime:

Joao: 8.232434
Maria: 9.75
Jose: 5.23

Não se preocupem com o formato dos números.

Testando a aplicação

Primeiramente, execute a aplicação criando instâncias dos objetos manualmente, e utilizando o "Code Pad" (View -> Code Pad).

Em seguida, crie uma classe de testes no BlueJ (botão direto, "new Class", "test") e em um método de teste público, com o nome testAluno , adicione o código abaixo. Este código irá criar 4 alunos, um professor, mandar os alunos fazer os relas e mandar o professor corrigir os relas. Ao final da execução deverá exibir uma tela com a nota do relatório de 3 destes 4 alunos.

Execute o teste (botão direito na classe de teste e "Test All"), e verifique se a nota dos 3 alunos é exibida e o teste passa.

Caso você encontre algum erro no código do teste abaixo, avise-nos (rápido) para que possamos corrigir. Você não pode alterar o código de teste para se adaptar a sua aplicação (nomes de métodos diferentes, etc), altere sua aplicação para se adaptar ao teste.

//criando os objetos
RelaQueue queue = new RelaQueue();
Professor prof = new Professor(queue);
AlunoEsforcado aluno1 = new AlunoEsforcado("John Smith", queue);
AlunoEsforcado aluno2 = new AlunoEsforcado("Mark Smith", queue);
AlunoSafoPreguicoso aluno3 = new AlunoSafoPreguicoso("Joseph Smith", queue);
AlunoSafoPreguicoso aluno4 = new AlunoSafoPreguicoso("Robert Smith", queue);
 
//teste de alunoesforcado
assertEquals(0.5, aluno1.getInteligencia(), 0.01);
assertEquals(1, aluno1.getDedicacao(), 0.01);
 
//teste de alunosafo
assertEquals(1.0, aluno3.getInteligencia(), 0.01);
assertTrue(aluno3.getDedicacao() != aluno3.getDedicacao()); //deve ser randomica
assertTrue(aluno3.getDedicacao() < 0.5);
 
//alunos comecam a fazer os relas
aluno1.fazEEntregaRelatorio();
 
//roubamos o relatório do primeiro aluno para investigá-lo
Relatorio rela1 = queue.dequeue();
assertEquals(aluno1, rela1.getAluno());
assertTrue(rela1.getAluno().getNome().equals("John Smith"));
assertTrue(rela1.getQualidade() < 0.9);
assertTrue(rela1.getQualidade() > 0.8);
assertTrue(rela1.getOriginalidade() < 0.7);
assertTrue(rela1.getOriginalidade() > 0.6);
 
//os outros continuam a fazer os relas
aluno2.fazEEntregaRelatorio();
aluno3.fazEEntregaRelatorio();
aluno4.fazEEntregaRelatorio();
 
//deve exibir a coreção dos relas dos aluno2, aluno3, e aluno4, nesta ordem
//pois "roubamos" o relatório do aluno1
prof.corrigirRelatorios();

Relatório

Crie seu relatório neste wiki, criando uma pagina(basta digitar o endereço na URL do browser) com o nome "relas:lab1_PRIMEIRONOME_SEGUNDONOME (ex.: "lab1_joao_silva" ) e escreva seu rela lá. Ao terminar, edite a página de relatórios e coloque um link para o seu relatório lá, em ordem alfabética de nome.

Anexe o código fonte das 6 classes criadas, arquivo por arquivo, sem compresão. Adicione "screenshots" (tire um print screen da tela e anexe o arquivo no seu rela, colocando-o "in-line" no relatório, usando o botão "insert image" da barra de ferramentas do wiki) da janela do BlueJ com as classes já compiladas, criação de instancias manualmente e janela de testes com os testes passando e resultado dos mesmos. Utilize o formato .jpg ou .png para as imagens. Detalhe os passos de execução do código. Comente os principais trechos de código no relatório, utilizando a tag de exibição de código. Comente o uso dos conceitos de orientação a objetos já discutidos em sala de aula, dizendo onde, como e porque foi utilizado cada conceito (ex.: conceito de herança, polimorfismo, mensagens). Faça uma conclusão rica, apontando sugestões para melhorar a aplicação, suas primeiras impressões do curso, etc.

Data limite para entrega do relatório: 13/08/2008

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