MAC 441/5714 - Programação Orientada a Objetos

Aula 22 - 8/6/05

Relacionamento entre Padrões de Projeto de Software

Os padrões do GoF são todos inter-relacionados, se citam, dependem um do outro e colaboram na criação de soluções sofisticadas para problemas complexos.
a contra-capa interna do livro possui um diagrama mostrando as principais inter-relações.

Double dispatch

Muitas das coisas que são feitas através de comandos de controle (como ifs ou cases) em progração procedimental, em POO são feitas através de polimorfismo. Num bom programa OO raramente se vê muitos comandos de controle no código ou longas seqüências de ifs, o que é relativamente comum em programação procedimental. Veremos a seguir um dos padrões OO que permitem isso.

O Problema:

Em geral, o método que é executado quando uma mensagem é enviada depende apenas do tipo do objeto que está recebendo a mensagem.
Mas, em alguns casos, o tipo do objeto que está sendo passado como parâmetro também é importante para se determinar o que deve ser executado.
Uma solução não-OO seria ter um comando case ou switch no método do destinatário e, dependendo do tipo do argumento, executar um código diferente.
Neste caso não-OO, cada vez que um novo tipo de parâmetro possa ser passado, o código do switch tem que ser estendido.
Mas, felizmente, há uma solução OO para isso que troca o switch por polimorfismo. Muito melhor, não?

A Solução:

Double Dispatching
O método do objeto que recebeu a mensagem, envia uma segunda mensagem ao objeto contido no argumento da primeira mensagem e se auto-passa como parâmetro (self).
Todos os objetos que podem ser passados como argumento na primeira mensagem devem ser capazes de entender a segunda mensagem.

Exemplinho simples:

meios de transmissão (email, carta, telefone) enviando conteúdo (texto, música, cobrança)
Se tenho código do tipo

MeioDeTransmissão c = new Carta();
c.envie (bachianasBrasileiras);

o objeto c precisaria saber qual o tipo de conteúdo que ele recebeu para que ele possa enviá-lo
uma forma (feia) seria verificar o tipo com um case ou seqüência de ifs
outra seria enviando uma segunda mensagem (double dispatching)

class Carta {
envie (Conteúdo cont) { cont.enviePorCarta (this); }
}
precisaríamos então ter o seguinte método na classe Música:
class Música {
enviePorCarta (Carta c) { c.escreva (this.partitura); }
enviePorEMail (EMail e) { e.anexe (this.arquivoMP3);}
enviePorTelefone (Telefonema t) { t.toque (this.arquivoAU); }
}

As operações aritméticas em Smalltalk usam DD fortemente pois ao se fazer num1 op num2 o objeto num1 não sabe exatamente qual operação op ele deve executar pois isso depende do tipo do objeto num2.
Exemplo com multiplicação em Smalltalk:

Integer>>* aNumber 
   “Não sabemos o tipo específico de aNumber portanto não sabemos o tipo de multiplicação”
   “Então enviamos uma mensagem para aNumber indicando que somos um inteiro”
   
   ^aNumber productFromInteger: self

Float>>productFromInteger: anInteger
   “Aqui sabemos o tipo dos dois fatores da multiplicação, já podemos multiplicar”
   ^anInteger asFloat * self
Float* aNumber 
   "Answer a Float that is the result of multiplying the receiver by the argument.  
   The primitive fails if it cannot coerce the argument to a Float"
   <primitive: 49>
   ^aNumber productFromFloat: self "this line is only executed if the primitive fails"
Double>>productFromInteger: anInteger
   ^anInteger asDouble * self

Exemplo da API de seriação de objetos em Java

A a = new A(); // A classe A implementa a interface java.io.Serializable.
ObjectOutputStream oos = new ObjectOutputStream();
oos.writeObject( a);

A implementação de ObjectOutputStream não sabe nada sobre a classe A mas ela chama o método writeObject na classe A passando si mesmo (this) como parâmetro. A classe A então faz chamadas de volta ao ObjectOutputStream que recebeu como parâmetro para gravar os valores dos seus atributos. Se os atributos são tipos primitivos, a recursão acaba e bytes são escritos no ObjectOutputStream, caso contrário ela continua utilizando o DD recursivamente.

Mais um exemplo muito interessante fornecido pelo nosso aluno Tiago Motta Jorge em um jogo tipo Asteroids que ele implementou:

Todos os objetos colidíveis do jogo herdam da classe abstrata TiWColisionObject.
Esta é uma boa classe para se colocar inteiramente nas notas de aula, pois ela define todos os métodos de double-dispatching.
Segue a classe:

public abstract class TiWColisionObject extends TiWObject {
private TiWArena arena;
private double theta;     // angle of the object

public TiWColisionObject(double x, double y, int w, int h) {
     super(x, y, w, h);
     this.arena = TiWArena.getInstance();
}

public TiWArena getArena() {
     return arena;
}

public void setTheta(double t) {
     theta = (t >= 0 && t <= 2 * Math.PI) ? t : 0.0;
}

public double getTheta() {
     return theta;
}

public boolean intersects(TiWObject o) {
                 return (
        (getX() - getWidth() / 2.0 <= o.getX() + o.getWidth() / 2.0)
        && (getX() + getWidth() / 2.0 >= o.getX() - o.getWidth() / 2.0)
        && (getY() - getHeight() / 2.0 <= o.getY() + o.getHeight() / 2.0)
        && (getY() + getHeight() / 2.0 >= o.getY() - o.getHeight() / 2.0)
     );
}

public void checkColision() {
     TiWObjectsContainer tiwObjects = TiWArena.getInstance().getObjects();
     TiWColisionObject other = null;
         for (TiWObject o : tiwObjects.getColidables()) {
           other = (TiWColisionObject) o;
           if (this.intersects(other)) {
             this.handleColision(other);
             break;
        }
     }
}

public void update() {
     checkColision();
}

// double dispatch default implementation for colision
public void colidedWithMiniMeteor(TiWColisionObject o) {
     // subclass responsibility!
}

public void colidedWithMediumMeteor(TiWColisionObject o) {
     // subclass responsibility!
}

public void colidedWithBigMeteor(TiWColisionObject o) {
     // subclass responsibility!
}

public void colidedWithShip(TiWColisionObject o) {
     // subclass responsibility!
}

public void colidedWithBonusBall(TiWColisionObject o) {
     // subclass responsibility!
}

public void colidedWithShot(TiWColisionObject o) {
     // subclass responsibility!
}

public void finalizeObject() {
     // subclass responsibility!
}

public abstract double getXDirection();
public abstract double getYDirection();
public abstract double getVelocity();
public abstract double getAcceleration();
public abstract void handleColision(TiWColisionObject o);
}
- Além dela, basta pegar dois objetos colidíveis e extrair sua implementação dos métodos de colisão. Por exemplo, um meteoro de tamanho grande e um tiro da nave:
BigMeteor.java:

public void handleColision(TiWColisionObject o) {
     o.colidedWithBigMeteor(this);
}

Shot.java:

public void colidedWithBigMeteor(TiWColisionObject o) {
     colidedWithMeteor(o);
}

public void colidedWithMediumMeteor(TiWColisionObject o) {
     colidedWithMeteor(o);
}

public void colidedWithMiniMeteor(TiWColisionObject o) {
     colidedWithMeteor(o);
}

private void colidedWithMeteor(TiWColisionObject o) {
     finalizeObject();
     ship.updateScore(o);
     o.finalizeObject();
}
- É interessante ressaltar o triple-dispatch que eu fiz. O código de tratamento de colisão entre tiros e meteoros fica no tiro. Logo, em algumas ocasiões ocorre um triple-dispatch, para se chegar nesta implementação. Isto centraliza um pouco o código.
- Também é interessante ressaltar o esquema desta classe abstrata TiWColisionObject. Ela define umas implementações default para todos os métodos de colisão. Sendo assim, se a colisão entre algum objeto e outro não for interessante, não é preciso sair implementando o método em todos os objetos colidíveis. Por exemplo, os tiros não afetam as bolinhas de bônus, mas estas surtem algum efeito ao colidirem com a nave.
O código-fonte do jogo está disponível como software livre em sourceforge.net/projects/tiwarriors

Referências

Descrição de DD como um padrão: http://www.object-arts.com/EducationCentre/Patterns/DoubleDispatch.htm
Double Dispatch no wikipedia: http://en.wikipedia.org/wiki/Double_dispatch
Double dispatching em Java: http://www.javaperformancetuning.com/articles/ddispatch.shtml

Página de MAC 441/5714
Página do Fabio
Página do DCC