En variant är "double dispatch"... dvs, du låter objektet som du inte vet vad det är bestämma vad som behöver göras. Antag att du har en klass Node som hanterar det som noder kan tänkas hantera (typ skicka vidare paket etc.) och en abstrakt klass/interface som heter Packet som typ HereAmIPacket, som meddelar var en nod är, NodeGroupPacket som meddelar vilka noder som är med i en grupp etc. Lösningen är då att ge Packet-klassen en metod som själv meddelar Noden om vad som ska göras:
abstract class Packet {
// ...
/** Får något att hända i noden */
public abstract void informNode(Node n);
}
...
class Node {
public void handleHereAmI(HereAmIPacket p){ ... }
public void handleNodeGroup(NodeGroupPacket p){ ... }
/**
* Får något att hända i noden (den viktiga biten).
* Anropas när ett paket anländer.
*/
public void packetArrived(Packet p){
p.informNode(this);
}
}
Sen gör du bara olika saker i subklasserna:
class HereAmIPacket extends Packet {
public void informNode(Node n){ n.handleHereAmI(this); }
}
class GroupPacket extends Packet {
public void informNode(Node n){ n.handleNodeGroup(this); }
}
Ger lite mer overhead (ytterst marginellt), men en betydligt renare design.