क्या करना है यदि समान इंटरफेस वाले वर्ग समान लेकिन अलग-अलग विधि हस्ताक्षर वाले हैं?

Question

यदि समान इंटरफ़ेस वाले वर्ग समान हैं लेकिन अलग-अलग विधि हस्ताक्षर हैं तो क्या करें?

मान लें कि मेरे पास अलग-अलग लागतों की गणना करने के लिए एक परियोजना है (अंतिम लागत कुल प्राप्त करने के लिए)।

मेरे कार्यक्रम में, कई कैलकुलेटर कक्षाएं हैं, अर्थात् ACostCalculator, BCostCalculator और इसी तरह। जब लागत की गणना करने के लिए calculate() विधि लागू की जाती है, तो लागत लागत कंटेनर भी उन लागत कैलकुलेटर को पास किया जाता है। एक अच्छी परिदृश्य में, मैं प्रत्येक लागत कैलकुलेटर के लिए CostCalculator इंटरफ़ेस बना सकता हूं।

हालांकि, विभिन्न लागतों की गणना के लिए विभिन्न संसाधनों की आवश्यकता होती है।

//getResource() are costly method while several costs need this. So do it outside calculate() method. 
ResourceA resourceA = getResourceA(); 
ResourceB resourceB = getResourceB(); 

CostContainer costContainer = new CostContainer(); 
CostCalculator aCostCalculator = new ACostCalculator(); 
... 
CostCalculator eCostCalculator = new ECostCalculator(); 

aCostCalculator.calculate(costContainer); 
bCostCalculator.calculate(costContainer) 
cCostCalculator.calculate(costContainer, resourceA); 
dCostCalculator.calculate(costContainer, resourceA); 
eCostCalculator.calculate(costContainer, resourceA, resourceB); 

तो हस्ताक्षर बिल्कुल वैसा ही है, मैं आसानी से एक पाश कर सकते हैं यह एक ही बार में करना है: मेरे वर्तमान कार्यक्रम में, यह तरह बनाते हैं। हालांकि, चूंकि वे समान लेकिन अलग हैं, इसलिए मैं एक अच्छा इंटरफ़ेस भी नहीं बना सकता।

मुझे यकीन नहीं है कि ऐसा करने के अच्छे तरीके हैं या नहीं। मैं क्या सोचते की

calculate(CostContainer costContainer, List<Object> resources); 

कोई भी विचार में करने के लिए सभी calculate() विधि सामान्यीकरण है सकते हैं? जवाब के लिए धन्यवाद।

Answer 1

यदि संसाधन कैलकुलेटर के जीवनकाल के लिए समान रहते हैं: संसाधनों को कैलकुलेटर के निर्माता को पास करें।

ResourceA resourceA = getResourceA(); 
ResourceB resourceB = getResourceB(); 

CostContainer costContainer = new CostContainer(); 

CostCalculator aCostCalculator = new ACostCalculator(); 
CostCalculator bCostCalculator = new BCostCalculator(); 
CostCalculator cCostCalculator = new CCostCalculator(resourceA); 
CostCalculator dCostCalculator = new DCostCalculator(resourceA); 
CostCalculator eCostCalculator = new ECostCalculator(resourceA, resourceB); 

aCostCalculator.calculate(costContainer); 
bCostCalculator.calculate(costContainer); 
cCostCalculator.calculate(costContainer); 
dCostCalculator.calculate(costContainer); 
eCostCalculator.calculate(costContainer); 

Answer 2

आप variadic arguments उपयोग कर सकते हैं:

public interface CostCalculatorInterface { 
    public void calculate(CostContainer container, Object... resources); 
} 

(या ResourceA और ResourceB का एक और सुपर क्लास के साथ Object बदलें)।

कक्षाएं इंटरफेस को लागू करने में, resources एक Object[] ताकि आप के रूप में resources[0], resources[1] और इतने पर उन्हें का उल्लेख कर सकते हो जाएगा।

Answer 3

यह कुछ ऐसा है कि आप वास्तव में जेनेरिक्स के साथ उपयोग करते हैं:

Resource resourceA = new ResourceA(); 
    Resource resourceB = new ResourceB(); 
    CostContainer costContainer = new CostContainer(); 
    CostCalculator<Resource> costCalculatorA = new ACostCalculator(); 
    costCalculatorA.calculate(costContainer,resourceA,resourceB); 
    CostCalculator<Resource> costCalculatorB = new BCostCalculator(); 
    costCalculatorB.calculate(costContainer,resourceA); 


interface Resource { 
    //Your code 
} 

class ResourceA implements Resource { 
    //Your code 
} 

class ResourceB implements Resource { 
    //Your code 
} 

class CostContainer { 
    //Your code 
} 

interface CostCalculator<T extends Resource> { 
    void calculate(CostContainer costContainer, T... resources); 
} 

class ACostCalculator implements CostCalculator<Resource>{ 

    @Override 
    public void calculate(CostContainer costContainer, Resource... resources) { 
     System.out.println("Test"); 
    } 
} 

class BCostCalculator implements CostCalculator<Resource>{ 

    @Override 
    public void calculate(CostContainer costContainer, Resource... resources) { 
     System.out.println("Test2"); 
    } 
} 

Answer 4

एक आम इंटरफेस के लिए हस्ताक्षर अलग की समस्या समस्या की तरह एक बहुत लग रहा है कि Adapter design pattern (object adapter variant) का हल:

आपकी स्थिति के लिए लागू, आप केवल गैर-अनुरूप कैलकुलेटर के लिए एडाप्टर का उपयोग करेंगे। वास्तव में केवल दो प्रकार के एडेप्टर हैं, हस्ताक्षर (costContainer, resourceA) के लिए टाइप 1 और हस्ताक्षर (costContainer, resourceA, resourceB) के लिए टाइप 2 हैं। अपने उदाहरण का उपयोग करना:

एडाप्टर के लाभ कर रहे हैं कि यह एक ज्ञात डिजाइन पैटर्न (1995 में GOF द्वारा प्रकाशित) है, यह अंतिम calculate(...) तरीकों है कि हस्ताक्षर अलग अनुमति देता है। संदर्भ परिवर्तन होने पर एडाप्टर को गतिशील रूप से अपडेट किया जा सकता है (उदा। संसाधनों में परिवर्तन)।

नुकसान स्पष्ट रूप से अतिरिक्त कक्षाएं, संकेतक इत्यादि हैं। यह चयनित उत्तर से अधिक जटिल है, लेकिन अधिक लचीला है, खासकर यदि आप एडैप्टेस के एपीआई को संशोधित नहीं कर सकते हैं।