एक समग्र पैटर्न में उदाहरण से बचें

Question

मैं विश्वविद्यालय के लिए एक परियोजना पर काम कर रहा हूं जहां हम एक गेम प्रोग्रामिंग कर रहे हैं। इस खेल में कई प्रभाव हो सकते हैं और एक प्रभाव इस बात को प्रभावित कर सकता है कि एक और प्रभाव कैसे व्यवहार करता है। अब विचारों में से एक एक समग्र पैटर्न का उपयोग कर रहा था जो पहले ठोस समाधान की तरह लग रहा था। यहां सबसे बड़ी समस्या यह है कि जिस तरह से प्रभाव व्यवहार करता है इस पर निर्भर करता है कि इसके साथ क्या प्रभाव पड़ता है और इसे ठीक करने के लिए एकमात्र तरीका यह है कि .getClass() या उदाहरण जिसका उपयोग हम हर कीमत से बचना चाहते हैं।

इस मुद्दे को डिजाइन करने के कुछ तरीके क्या हैं?

संपादित करें (एक छोटा सा उदाहरण): मैं एक स्पष्ट कोड उदाहरण नहीं है, लेकिन मैं निम्नलिखित उदाहरण के साथ एक सा स्पष्ट करने की कोशिश करेंगे:

तो खेल हथगोले है (जो स्पष्ट रूप से विस्फोट कर सकते हैं और नुकसान का कारण बनता है), इस विस्फोट को "विस्फोट प्रभाव" के रूप में देखा जाता है। जिस ग्रेनेड पर स्थित है वह वर्ग रनटाइम (PowerfailureEffect) पर पावरफाइलर हो सकता है। विस्फोट प्रभाव और PowerfailureEffect युग्मित किया जा सकता है और इससे विस्फोट मजबूत हो जाता है और अधिक नुकसान होता है। विस्फोट प्रभाव को अन्य प्रभावों के साथ जोड़ा जा सकता है जिससे विस्फोट क्षति और भी अलग तरीके से व्यवहार कर सकती है

Answer 1

आप विज़िटर डिज़ाइन पैटर्न का उपयोग कर सकते हैं। सभी प्रभाव वर्ग एक प्रभाव इंटरफ़ेस लागू करता है। मुख्य श्रेणी प्रभाव इंटरफ़ेस विधि का उपयोग करके EffectB क्लास से पूछती है कि इसे कैसे व्यवहार करना चाहिए। EffectB कक्षा में प्रभाव की विधि का कार्यान्वयन मुख्य वर्ग में सही विधि को कॉल करता है।

Answer 2

एक आम एंटी-पैटर्न प्रकार की जांच का उपयोग कर रहा है, उदाहरण के लिए पॉलिमॉर्फिज्म के बजाय instanceof के साथ। यहां एक साधारण उदाहरण है।

public class Shape { 
    public void draw() { 
     if (this instanceof Square) { 
      // Draw a square 
     } else if (this instanceof Circle) { 
      // Draw a circle 
     } 
    } 
} 

public class Square extends Shape { 
    // ... 
} 

public class Circle extends Shape { 
    // ... 
} 

नोट वर्ग Shape में draw() विधि में, हम जान सकते है कि क्या मौजूदा वस्तु के प्रकार को देखते हुए, और उसके बाद उपयुक्त कोड को क्रियान्वित करते हुए आकर्षित करने के लिए। इसके कई नुकसान हैं: कक्षा Shape को इसके सभी उप-वर्गों के बारे में जानने की आवश्यकता है, और यदि आप एक नया आकार जोड़ना चाहते हैं, तो आपको कक्षा Shape भी संशोधित करना होगा। यह बहुरूपता का उपयोग करने के उपवर्गों में draw() विधि अधिभावी द्वारा काफी बेहतर है:

public abstract class Shape { 
    public abstract void draw(); 
} 

public class Square extends Shape { 
    public void draw() { 
     // Draw a square 
    } 
} 

public class Circle extends Shape { 
    public void draw() { 
     // Draw a circle 
    } 
} 

इस तरह, वर्ग Shape अपने उपवर्गों के सभी के बारे में पता करने की जरूरत नहीं है, आप एक जोड़ने के लिए Shape को संशोधित करने की जरूरत नहीं है नया आकार और सभी तर्क जो एक विशेष आकार से संबंधित है वह उस स्थान पर है जहां यह संबंधित है (उस आकार के लिए कक्षा)।

Answer 3

एक और इंटरफ़ेस के बारे में कैसे। हो सकता है कि विभिन्न Modifier इंटरफेस हैं जो प्रभाव लागू करते हैं। ये संशोधक "वृद्धि एक्स्प्लोसिव पावर" जैसी चीजें कर सकते हैं। यह देखने के लिए कि कक्षा संशोधक लागू करती है और फिर एक प्रभाव दूसरे को संशोधित कर सकता है, आप instanceof कर सकते हैं।

नोट: एक इंटरफ़ेस पर instanceof करना काफी स्वीकार्य है - यदि आप यह क्या कर सकते हैं, लेकिन यह किस एपीआई पर आधारित है, तो आप कुछ नहीं कर सकते हैं।

Answer 4

public void test(){ 
    methodForWaterEffect(new WaterEffect()); 
    combinationAttack1(new FireEffect(), new WaterEffect()); 
} 

interface Effect{ 
    public void activateEffect(); 
} 

class FireEffect implements Effect{ 

    @Override 
    public void activateEffect() { 
     System.out.println("Fire!"); 
    } 

} 

class WaterEffect implements Effect{ 

    @Override 
    public void activateEffect() { 
     System.out.println("Water!"); 
    } 

} 
public void combinationAttack1(FireEffect fe, WaterEffect we){ 
    //your algorithm here 

} 

public void methodForWaterEffect(WaterEffect fe){ 
    fe.activateEffect(); 
} 

मेरे पास एक बहुत ही सरल सुझाव है। प्रभाव को बुलाए जाने वाले इंटरफ़ेस को लागू करने वाले प्रत्येक प्रभाव के लिए कक्षाएं क्यों न बनाएं। इसके अलावा, यदि आप संयोजन हमलों का अनुकरण करने की कोशिश कर रहे हैं, तो उन संयोजन हमलों में से प्रत्येक के लिए फ़ंक्शन क्यों न करें?

तो अपने उदाहरण में, यह

public void combination2(PoisonEffect pe, PowerFailureEffect pf){ 

} 

यह हो सकता है काम का बोझ लगता है होने जा रहा है, लेकिन मैं इस बहुत अच्छी तरह से अपने कोड अलग करता है और बाद में आप इसे आसान अपने कोड के प्रबंधन के लिए मिल सकती है लगता है।

कृपया ध्यान दें कि सादगी के लिए, वे अलग-अलग वर्ग फ़ाइलों = डी में नहीं हैं।