डिज़ाइन पैटर्न पैटर्न?

Question

मैं जावा में एक वर्ग पदानुक्रम है मान लीजिए:

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

और मैं एक ही पैकेज में एक और वर्ग है:

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

जहां मैं कुछ प्रत्येक आइटम प्रकार के लिए अलग करना चाहते हैं, लेकिन मैं डॉन अलग-अलग Item कक्षाओं (MusicBox, TypeWriter, SoccerBall) में उस क्रिया को परिभाषित नहीं करना चाहते हैं।

एक तरीका यह संभाल करने के लिए है:

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 ... 
     } 
    } 
} 

यह काम करता है लेकिन यह वास्तव में भद्दा लगता है। क्या मुझे ऐसा करने का बेहतर तरीका है, जब मुझे विशेष मामलों के बारे में पता है? (जाहिर है, अगर Item एक विधि शामिल doSomethingSpecial तो मैं सिर्फ इतना है कि आइटम की विधि यह क्या टाइप कर रहा है देखभाल के बिना कॉल कर सकते हैं, लेकिन स्वयं आइटम मैं इसे से कैसे निपटते हैं के भीतर होने के लिए है कि भेदभाव चलेगा कि मैं नहीं चाहता?)

Answer 1

मुझे लगता है कि मैं नियंत्रण से उलट करने के विचार का उपयोग करने के लिए जा रहा हूँ और 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); 
     } 
    } 
} 

और फिर निम्न है, जो कम से कम प्रति add() कॉल instanceof एक करने के लिए चेक कम कर देता है कर :

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

आप आइटम के लिए पुल पैटर्न बना सकते हैं, जिसमें दूसरी तरफ जोड़ने के लिए संबंधित प्रक्रियाएं होती हैं() कहा जाता है। आप मिश्रण में एक कारखाना विधि भी जोड़ सकते हैं।

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

उम्मीद है कि इससे मदद मिलती है।

Answer 3

जावा में आप एक आगंतुक (जैसे) पैटर्न के साथ एकाधिक प्रेषण कर सकते हैं। आइटम कार्यान्वयन में प्रसंस्करण तर्क को शामिल करने की आवश्यकता नहीं है, उन्हें केवल 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

आइटम इंटरफ़ेस में कुछ कॉलबैक फ़ंक्शन को परिभाषित क्यों नहीं करें?

public Interface Item { 
    void onCallBack(); 
} 

फिर प्रत्येक श्रेणी में जो संगीत बॉक्स जैसे आइटम लागू करता है, उसे कॉलबैक फ़ंक्शन को कार्यान्वित करना चाहिए।

public class MusicBox { 
    @override 
    public void onCallBack() { 
    // business logic 
    ... 
    ... 
    } 
} 

फिर आप एक प्रेषक बना सकते हैं, जिसका नाम आप "स्पेशलइटम प्रोसेसर" है।

public SpecialItemProcessor { 
    private final Item _item; 

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

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

और फिर, ग्राहक वर्ग जो SpecialItemProcessor बस, विधि कह सकते हैं की तरह होता है में:

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

वास्तव में, सी ++ में, इस गतिशील बाध्यकारी है। और यही कारण है कि शुद्ध अमूर्त वर्ग मौजूद है ...