Root at 14:48, 21 February 2019

2019-02-21T14:48:56Z

Root: /* Resultados */

2013-11-21T22:21:03Z

Resultados

← Older revision		Revision as of 22:21, 21 November 2013
Line 216:		Line 216:

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

Root: /* Resultados */

2013-11-21T22:20:41Z

Resultados

← Older revision		Revision as of 22:20, 21 November 2013
Line 218:		Line 218:
	[[catagory:PO]]		[[catagory:PO]]
	[[category:PO Exemplos]]		[[category:PO Exemplos]]
	[[~~categoru~~:Java]]		[[category:Java]]

Root: Created page with "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 si..."

2013-11-21T22:20:06Z

Created page with "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 si..."

New page

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]]

Visitor (padrão de desenho)/Expressões Aritméticas Simples - Revision history

Root at 14:48, 21 February 2019

Root: /* Resultados */

Root: /* Resultados */

Root: Created page with "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 si..."