Laboratório 3 - 26/03/2012

Uma dica: baixe o projeto Eclipse da terceira semana de aula e importe ele no Eclipse antes de começar, assim você pode ver como os conceitos foram aplicados em sala.

Não esqueça de criar um projeto Eclipse chamado Lab3 para os exercícios, e um scrapbook nesse projeto para você poder fazer experimentos. O objetivo deste laboratório é exercitar a criação de métodos para interfaces e suas classes; não se esqueça de criar pelo menos uma classe de teste (usando File->New->JUnit Test Case...) para testar seus métodos.

TINY é uma linguagem de programação bem simples, mas relativamente completa, contendo expressões aritméticas, variáveis e atribuição, entrada e saída simples, e comandos de teste e laços. Por exemplo, o programa TINY abaixo calcula o fatorial de um número pedido na entrada e o mostra na saída:

read x; 
if 0 < x then
  fact := 1;
  repeat 
    fact := fact * x;
    x := x - 1
  until x = 0;
  write fact { saida }
end

Nesse exercício vocês irão implementar classes que modelam a estrutura de um programa TINY, e métodos para executar expressões e comandos TINY. As estruturas de um programa TINY se dividem em dois grupos, expressões e comandos, então comece definindo as interfaces Expressao e Comando. As classes a seguir modelam expressões, e todas elas devem implementar a interface Expressao:

Num modela um numeral, e contém o valor do mesmo (um double).

Var modela uma variável, e contém o nome da variável e seu valor atual (também um double). O construtor dessa classe deve receber apenas o nome, e inicializar o valor da variável como 0.

Soma, Sub, Mul e Div modelam as quatro operações aritméticas, e contêm duas expressões, para o lado esquerdo e o lado direito da operação.

Igual e Menor modelam as operações de comparação, e também contêm expressões para o lado esquerdo e direito da operação.

Implemente as classes para todos os tipos de expressão, com seus respectivos construtores. Agora vocês irão adicionar um método double valor() à interface Expressao, e implementar esse método para todas as classes acima. Nas operações de comparação valor() deve retornar 0 se a operação for falsa e 1 se for verdadeira. Escreva testes para cada implementação de valor().

As classes a seguir modelam os comandos, e todas elas implementam a interface Comando:

Vazio modela um comando que não faz nada (um corpo vazio de um if, por exemplo), e não tem campos.

Read modela um comando de leitura, e contém a variável na qual o valor lido será armazenado.

Write modela um comando de escrita, e contém a expressão cujo valor será escrito.

Atrib modela um comando de atribuição, e contém a variável a ser atribuída e a expressão cujo valor será atribuído.

If modela um comando if/then/else, e contém a expressão de teste e dois comandos, um para a parte then e outro para a parte else.

Repeat modela um comando repeat/until, e contém um comando para o corpo do laço e uma expressão para a condição de parada.

Seq modela uma sequência de dois comandos.

Implemente as classes para todos os tipos de comando, com seus respectivos construtores. Agora adicionem um método void executa() à interface Comando, e implementem esse método para todas as classes acima. Usem a sua intuição, e não se esqueçam dos testes.

  // Variável global para a entrada padrão
  static java.util.Scanner STDIN = new java.util.Scanner(System.in);

  // Função para ler um double da entrada padrão
  static double readDouble() {
    return STDIN.nextDouble();
  }

O trecho de código a seguir instancia um programa TINY com a estrutura do programa fatorial acima. Copie-o para o scrapbook e execute para ver o resultado:

Var x = new Var("x");
Var fat = new Var("fat");
Comando prog = 
  new Seq(new Read(x),
          new If(new Menor(new Num(0), x),
                 new Seq(new Atrib(fat, new Num(1)),
                         new Seq(new Repeat(new Seq(new Atrib(fat, new Mul(fat, x)),
                                                    new Atrib(x, new Sub(x, new Num(1)))),
                                            new Igual(x, new Num(0))),
                                 new Write(fat))),
                 new Vazio()));
prog.executa();

O trecho de código a seguir calcula a média final das três provas pelas nossas regras de avaliação:

/*
* read p1;
* read p2;
* read p3;
* if p1 < p2 then
*   if p1 < p3 then
*     write (p2 + p3) / 2
*   else
*     write (p1 + p2) / 2
*   end
* else
*   if p2 < p3 then
*     write (p1 + p3) / 2
*   else
*     write (p1 + p2) / 2
*   end
* end
*/
Var p1 = new Var("p1");
Var p2 = new Var("p2");
Var p3 = new Var("p3");
Comando prog = new Seq(new Read(p1),
               new Seq(new Read(p2),
               new Seq(new Read(p3),
                       new If(new Menor(p1,p2),
                              new If(new Menor(p1,p3),
                                     new Write(new Div(new Soma(p2,p3),
                                                       new Num(2))),
                                     new Write(new Div(new Soma(p1,p2),
                                                       new Num(2)))),
                              new If(new Menor(p2,p3),
                                     new Write(new Div(new Soma(p1,p3),
                                                       new Num(2))),
                                     new Write(new Div(new Soma(p1,p2),
                                                       new Num(2))))))));

prog.executa();

Enviando

Crie um arquivo .zip com todo o projeto que você criou e mande para esse email até o dia 09/04. Esse trabalho vale 0,3 na nota de exercícios, e poderá ser feito em dupla. Não esqueça de escrever quem são os autores no email, e em um comentário no(s) seu(s) arquivo(s) .java.