इंटरफेस xxx को विभिन्न तर्कों के साथ एक से अधिक बार लागू नहीं किया जा सकता है:

Question

implements GenericObserver<DataService, Tools>, GenericObserver<MobileService, Tools> 

विभिन्न तर्कों के साथ एक से अधिक बार लागू नहीं किया जा सकता है।

public interface GenericObserver<S, D> { 

    void update(S sender, D data); 
} 

मैं क्या कर सकता:

यह मेरा इंटरफ़ेस है? मुझे DataService और MobileService की आवश्यकता है।

मैं सामान्य T बजाय DataService और MobileService इस्तेमाल करने की कोशिश, लेकिन मैं एक त्रुटि है कि T मौजूद नहीं है मिलता है।

Answer 1

एक संभावना:

abstract class Service {} 

class DataService extends Service {} 

class MobileService extends Service {} 

class Foo implements GenericObserver<Service, Tools> { 
    void update(Service sender, Tools data) { 
     if (sender instanceOf DataService) { 
      // do something 
     } else if (sender instanceOf MobileService) { 
      // do something else 
     } else { 
      // throw some notImplemented exception 
     } 
    } 
} 

Visitor pattern एक और संभावना (GenericObserver दर्शनीय जा रहा है) है।

Answer 2

यह जावा की वजह से type erasure कर रहा है। संकलन के बाद, सभी सामान्य प्रकार मिटा दिए जाते हैं, दोनों इंटरफेस बाइटकोड में समान दिखते हैं।

Answer 3

मैं दो संभव परिदृश्यों कारण है कि आप ऐसा करने के लिए प्रयास कर रहे हैं:

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

दूसरा परिदृश्य - ये इंटरफेस आपके कार्यान्वयन विवरण का हिस्सा हैं। फिर आप अपने लक्ष्य को प्राप्त करने के लिए आंतरिक कक्षाओं (या स्थिर नेस्टेड कक्षाओं) का उपयोग कर सकते हैं। उदाहरण के लिए:

public class OuterClass { 

    private String hello = "Hello"; 
    private String world = "World"; 

    private class InnerClass1 implements GenericObserver<DataService, Tools> { 
     public String interfaceMethod() { 
      return hello + " " + world; 
     } 
     // more implementation 
    } 

    private class InnerClass2 implements GenericObserver<MobileService, Tools> { 
     // implementation 
    } 

} 

आप तो आप आसानी से वर्ग आप इस एक सा काल्पनिक उदाहरण से देख सकते हैं के रूप में शामिल के क्षेत्र का उपयोग कर सकते इनर क्लासों का उपयोग करते हैं।

Answer 4

कार्यान्वयन कक्षा इन इंटरफेस को क्षमताओं प्रदान कर सकती है लुकअप विधि नीचे दी गई विधि। इस पैटर्न का लाभ, कक्षाओं के एपीआई की विस्तारशीलता और uncoupling है।

interface DataObserver extends GenericObserver<DataService, Tools> { } 

interface MobileObserver extends GenericObserver<MobileService, Tools> { } 

public class Implementor { 

    private DataObserver dataObserver; 
    private MobileObserver mobileObserver; 

    public <T> T lookup(Class<T> klazz) { 
     ... return dataObserver; 
    } 

} 

की