modèle de conception de répartition?

Question

Supposons que j'ai une hiérarchie de classes en Java:

interface Item { ... }; 
class MusicBox implements Item { ... }; 
class TypeWriter implements Item { ... }; 
class SoccerBall implements Item { ... }; 

et j'ai une autre classe dans le même package:

class SpecialItemProcessor { 
    public void add(Item item) 
    { 
     /* X */ 
    } 
} 

où je veux faire quelque chose de différent pour chaque type d'élément, mais je ne ne veulent pas définir cette action dans les différentes classes Item (MusicBox, TypeWriter, SoccerBall).

Une façon de gérer est:

class SpecialItemProcessor { 
    public void add(Item item) 
    { 
     if (item instanceof MusicBox) 
     { 
      MusicBox musicbox = (MusicBox)item; 
      ... do something ... 
     } 
     else if (item instanceof MusicBox) 
     { 
      TypeWriter typewriter = (TypeWriter)item; 
      ... do something ... 
     } 
     else if (item instanceof SoccerBall) 
     { 
      SoccerBall soccerball = (SoccerBall)item; 
      ... do something ... 
     } 
     else 
     { 
      ... do something by default ... 
     } 
    } 
} 

Cela fonctionne, mais il semble vraiment maladroit. Y a-t-il une meilleure façon de faire cela, quand je connais des cas spéciaux? (évidemment si Item contient une méthode doSomethingSpecial alors je peux simplement appeler la méthode de cet article sans se soucier de quel type il est, mais si je ne veux pas que cette différenciation se produise dans l'article lui-même, comment traiter?)

Answer 1

Je pense que je vais utiliser l'idée de l'inversion du contrôle et de la visitor pattern:

interface Item { 
    public void accept(Visitor visitor); 
    ... 

    public interface Visitor { 
     public void visit(Item item); 
    } 
} 


class MusicBox implements Item { 
    public interface Visitor extends Item.Visitor { 
     public void visitMusicBox(MusicBox item); 
    } 
    ... 
    @Override public accept(Item.Visitor visitor) 
    { 
     if (visitor instanceof MusicBox.Visitor) 
     { 
      ((MusicBox.Visitor)visitor).visitMusicBox(this); 
     } 
    } 
} 

class TypeWriter implements Item { 
    public interface Visitor extends Item.Visitor { 
     public void visitTypeWriter(TypeWriter item); 
    } 
    ... 
    @Override public accept(Item.Visitor visitor) 
    { 
     if (visitor instanceof TypeWriter.Visitor) 
     { 
      ((TypeWriter.Visitor)visitor).visitTypeWriter(this); 
     } 
    } 
} 

class SoccerBall implements Item { 
    public interface Visitor extends Item.Visitorr { 
     public void visitSoccerBall(SoccerBall item); 
    } 
    ... 
    @Override public accept(Item.Visitor visitor) 
    { 
     if (visitor instanceof SoccerBall.Visitor) 
     { 
      ((SoccerBall.Visitor)visitor).visitSoccerBall(this); 
     } 
    } 
} 

puis effectuez les opérations suivantes, qui réduit au moins la instanceof à un chèque par add() appel :

class SpecialItemProcessor 
    implements 
     MusicBox.Visitor, 
     TypeWriter.Visitor, 
     SoccerBall.Visitor, 
     Item.Visitor 
{ 
    public void add(Item item) 
    { 
     item.accept(this); 
    } 
    @Override public void visitMusicBox(MusicBox item) 
    { 
     ... 
    } 
    @Override public void visitTypeWriter(TypeWriter item) 
    { 
     ... 
    } 
    @Override public void visitSoccerBall(SoccerBall item) 
    { 
     ... 
    } 
    @Override public void visit(Item item) 
    { 
     /* not sure what if anything I should do here */ 
    } 
} 

Answer 2

Vous pouvez créer un modèle de pont pour Item, dans lequel l'autre côté était les processus associés à faire lorsque add() est appelé. Vous pouvez également ajouter une méthode d'usine au mélange.

class SpecialItemProcessor { 
    public void add(Item item) 
    { 
    Process p = Item.createCorrespondingProcessor(p); 
    p.doWhenAddin(); 
    } 
} 

Espérons que cela aide.

Answer 3

En Java, vous pouvez effectuer plusieurs répartitions avec un modèle visiteur (similaire). Les implémentations Item n'ont pas besoin de contenir la logique de traitement, elles ont juste besoin d'un type de méthode accept().

public interface Item { 
/** stuff **/ 

void processMe(ItemProcessor processor); 

} 

public interface ItemProcessor { 

void process(MusicBox box); 

void process(SoccerBall ball); 

//etc 

} 

public class MusicBox implements Item { 

    @Override 
    public void processMe(ItemProcessor processor) { 
    processor.process(this); 
    } 

} 

public class ItemAddingProcessor implements ItemProcessor { 

    public void add(Item item) { 
    item.processMe(this); 
    } 

    @Override 
    public void process(MusicBox box) { 
    //code for handling MusicBoxes 
    //what would have been inside if (item instanceof MusicBox) {} 
    } 

//etc 
} 

Answer 4

Pourquoi ne pas définir une fonction de rappel sur l'interface Item? Ensuite, dans chaque classe qui implémente Item, tel que MusicBox, elle doit implémenter la fonction de rappel. Puis vous pouvez créer un répartiteur, que vous nommez "SpecialItemProcessor".

public SpecialItemProcessor { 
    private final Item _item; 

    public SpecialItemProcessor(Item item) { 
    _item = item; 
    } 

    public dispatch() { 
    _item.onCallBack() 
    } 
} 

Et puis, dans la classe Client qui contient le SpecialItemProcessor pourrait simplement appeler la méthode, comme:

public void XXXX() { 
    .... 
    SpecialItemProcessor specialItemProcessor = new SpecialItemProcessor(new MusicBox()); 
    specialItemProcessor.dispatch(); 
    .... 
} 

En fait, en C++, c'est la liaison dynamique. Et c'est pourquoi la classe abstraite pure existe ...