View source for Visitor (padrão de desenho)/Expressões Aritméticas Simples

O exemplo seguinte mostra um exemplo de uso do padrão Visitor.

O ponto de partida é uma hierarquia de expressões inteiras: neste exemplo, usam-se as funções aritméticas simples e um valor literal.

Para motivar o uso do padrão, considere-se a class '''ADD''' (soma binária), definida como se segue ('''BinaryFunction''' é uma superclasse abstracta comum a todas as operações binárias, que contém dois atributos do tipo '''Content''' (a superclasse de todas as expressões; neste primeiro exemplo, assume-se que declara o método '''value()''', que retorna o valor calculado).

Nesta classe, o método '''value()''' calcula o valor da expressão recursivamente, primeiro, pelo lado esquerdo ('''left()''') e, depois, pelo lado direito ('''right()''').
<java5>
public class ADD extends BinaryFunction {
  public int value() {
    return left().value() + right().value();
  }
}
</java5>

Esta implementação é suficiente para a avaliação da expressão. No entanto, que seria necessário alterar para conseguir utilizar a expressão '''ADD''' para outro fim? Por exemplo, para a traduzir para C? ou para outro fim?

As respostas àquelas perguntas poderiam ser todas "acrescentar um método para esse fim". No entanto, isso vem alterar a definição original da classe e novas evoluções são igualmente acompanhadas de impacto negativo e generalizado sobre este tipo de classes (as alterações teriam, potencialmente, que ser realizadas também em classes semelhantes).

Utilizando o padrão Visitor, é possível remover as dependências de implementações específicas das classes de uma hierarquia de dados (esta hierarquia é, frequentemente, um Composite criado por uma fábrica).

== Classes das Expressões (Composite) ==

As classes das expressões estão organizadas segundo o padrão Composite e assentam sobre uma interface de topo. Escolheu-se uma interface e não uma classe abstracta por simplicidade e porque não há consequências relativamente a repetição de código.

<java5>
public interface Content {
  int accept(Visitor v);
}
</java5>

Note-se que a interface, embora seja um tipo abstracto (nunca sendo realmente processada pelo "visitor"), tem de declarar uma interface comum a todas as expressões. Dada a simplicidade do cenário, apenas é necessário o método '''accept'''. Note-se que não é especificado qual o "visitor" específico.

Abaixo desta interface existem duas classes que a implementam: a dos literais ('''Literal''') e a das funções binárias ('''BinaryFunction'''). Assume-se que os literais são os únicos que guardam valores inteiros e que todas as outras expressões se definem recursivamente (Composite).

Note-se a implementação de '''accept'''.
<java5>
public class Literal implements Content {
  private int _value;
  public Literal(int value) { _value = value; }
  public int accept(Visitor v) { return v.visitLiteral(this); }
  public int value() { return _value; }
}
</java5>

A classe de base para as funções binárias limita-se a definir os atributos e métodos relacionados. Sendo abstracta, não necessita definir '''accept''' (será definido por todas as suas subclasses concretas).

<java5>
public abstract class BinaryFunction implements Content {
  private Content _left;
  private Content _right;
  public BinaryFunction(Content left, Content right) { _left = left; _right = right; }
  public Content left() { return _left; }
  public Content right() { return _right; }
}
</java5>

Finalmente, as quatro classes das expressões aritméticas simples (soma, subtracção, multiplicação, divisão), são definidas. Note-se a extrema simplicidade destas classes: ao ser utilizado um "visitor", o comportamento delas migrou para as classes do padrão Visitor, deixando apenas a definição da inicialização e o método '''accept'''.

<java5>
public class ADD extends BinaryFunction {
  public ADD(Content left, Content right) { super(left, right); }
  public int accept(Visitor v) { return v.visitADD(this); }
}
</java5>

<java5>
public class SUB extends BinaryFunction {
  public SUB(Content left, Content right) { super(left, right); }
  public int accept(Visitor v) { return v.visitSUB(this); }
}
</java5>

<java5>
public class MUL extends BinaryFunction {
  public MUL(Content left, Content right) { super(left, right); }
  public int accept(Visitor v) { return v.visitMUL(this); }
}
</java5>

<java5>
public class DIV extends BinaryFunction {
  public DIV(Content left, Content right) { super(left, right); }
  public int accept(Visitor v) { return v.visitDIV(this); }
}
</java5>

== Classes de Visita ("visitors") (Visitor) ==

A interface '''Visitor''' define os métodos que devem ser implementados por todas as implementações. Implementações particulares podem definir outros métodos ou mesmo atributos. Por simplicidade, declara-se o retorno como um inteiro (isto permite que sejam obtidos valores recursivamente quando for apropriado).

<java5>
public interface Visitor {
  int visitADD(ADD c);
  int visitSUB(SUB c);
  int visitMUL(MUL c);
  int visitDIV(DIV c);
  int visitLiteral(Literal c);
}
</java5>

No exemplo que aqui se apresenta, define-se, primeiro, um "visitor" para avaliação de expressões. A sua passagem a um método '''accept''' é como a chamada, no modelo original, ao método '''value''' sobre a classe original correspondente.

<java5>
public class Evaluator implements Visitor {
  public int visitADD(ADD c) {
    return c.left().accept(this) + c.right().accept(this);
  } 
  public int visitSUB(SUB c) {
    return c.left().accept(this) - c.right().accept(this);
  } 
  public int visitMUL(MUL c) {
    return c.left().accept(this) * c.right().accept(this);
  } 
  public int visitDIV(DIV c) {
    return c.left().accept(this) / c.right().accept(this);
  } 
  public int visitLiteral(Literal c) {
    return c.value();
  } 
}
</java5>

Como se pode ver, a recursão termina nos literais. Compare-se ainda esta implementação com a classe '''ADD''' mostrada acima.

De seguida, para demonstrar como a funcionalidade pode ser muito diferente de classe de visita para classe de visita, mostra-se a classe '''CWriter''' que é capaz de produzir o código C para avaliar uma expressão.

<java5>
public class CWriter implements Visitor {
  String _cProgram = "";
  public String toString() {
    String program = "#include <stdio.h>\nint main() {\n\tprintf(\"%d\\n\", ";
    program += _cProgram;
    program += ");\n\treturn 0;\n}\n";
    return program;
  }
  public int visitADD(ADD c) {
    _cProgram += "(";
    c.left().accept(this);
    _cProgram += "+";
    c.right().accept(this);
    _cProgram += ")";
    return 0;
  }
  public int visitSUB(SUB c) {
    _cProgram += "(";
    c.left().accept(this);
    _cProgram += "-";
    c.right().accept(this);
    _cProgram += ")";
    return 0;
  }
  public int visitMUL(MUL c) {
    _cProgram += "(";
    c.left().accept(this);
    _cProgram += "*";
    c.right().accept(this);
    _cProgram += ")";
    return 0;
  }
  public int visitDIV(DIV c) {
    _cProgram += "(";
    c.left().accept(this);
    _cProgram += "/";
    c.right().accept(this);
    _cProgram += ")";
    return 0;
  }
  public int visitLiteral(Literal c) {
    _cProgram += Integer.toString(c.value());
    return 0;
  }
}
</java5>

A ideia é produzir uma cadeia de caracteres com o programa C completo. De seguida, o método '''toString''' (o processo poderia ser outro) apresenta o programa equivalente. Utiliza-se este método por simplicidade: numa outra situação, o seu nome poderia ser outro.

== Aplicação ==

Finalmente, a aplicação começa por criar a composição (simulando uma fábrica) e envia instâncias das duas classes de visita, imprimindo os respectivos resultados.

<java5>
public class App {
  public static void main(String[] args) {
    // 1 + 2 * 3
    Content c = new ADD(new Literal(1), new MUL(new Literal(2), new Literal(3)));
    //
    int value = c.accept(new Evaluator());
    System.out.println("1 + 2 * 3 = " + value);
    //
    Visitor cWriter = new CWriter();
    c.accept(cWriter);
    System.out.println("==========================================");
    System.out.println(cWriter);
  }
}
</java5>

== Resultados ==

O resultado é obtido através da execução do método '''main''' (assume-se a compilação prévia de todas as classes):

 java App

A saída é a seguinte:

<text>
1 + 2 * 3 = 7
==========================================
#include <stdio.h>
int main() {
        printf("%d\n", (1+(2*3)));
        return 0;
}
</text>

[[category:Ensino]]
[[catagory:PO]]
[[category:PO Exemplos]]
[[categoru:Java]]