जावा: दो संबंधित जेनरिक प्रकार के साथ एक मानचित्र की घोषणा (? <T> नक्शा <कक्षा <फैली ClassA <T>>, कक्षा <फैली ClassB <T> >>)

Question

यह संभव एक मानचित्र कि के लिए एक विशिष्ट उपवर्ग की चाबी से नक्शे घोषित करने के लिए है एक विशिष्ट उपclass के मूल्य लेकिन यह सुनिश्चित करना कि दोनों वर्ग एक ही प्रकार पैरामीटर साझा करते हैं?

पृष्ठभूमि के लिए:

ClassA और ClassB दोनों एक साझा संसाधन

public abstract class ClassA<T> { 
     public abstract T getResource() ; 
} 

public abstract class classB<T> { 
     public abstract void consoumeResource(T resource); 
} 

मैं ClassA और ClassB के क्रियान्वयन से नक्शा और सुनिश्चित केवल 'उपयुक्त' जोड़े को एक साथ रखा जा सकता है करना चाहते हैं के लिए व्यवहार को लागू एक प्रविष्टि में

Answer 1

एक और तरीका अपना खुद का Map कार्यान्वयन प्रदान करना होगा।

public class CompatibleHashMap<T> extends HashMap<ClassA<T>, ClassB<T>> { 

} 

अब, एक CompatibleHashMap<String> केवल मदद से आप कुंजी के रूप में ClassA<String> रख दिया और ClassB<String> मूल्यों के रूप में: वहाँ बहुत कोड यदि आप किसी मौजूदा कार्यान्वयन का विस्तार, और अपने नए प्रकार का उपयोग की जरूरत नहीं है।

संपादित करें:

आप अपनी टिप्पणी में उल्लेख किया है, इस तरह से आप एक Map कार्यान्वयन के लिए अपने आप को बांधने कर रहे हैं।

public class CompatibleMap<T> implements Map<ClassA<T>, ClassB<T>> { 

    private Map<ClassA<T>, ClassB<T>> map; 

    public CompatibleMap(Map<ClassA<T>, ClassB<T>> map) { 
     this.map = map; 
    } 

    @Override 
    public Set<List<T>> keySet() { 
     return map.keySet(); 
    } 
    // ... implement all other Map methods by calling the method on map. 
} 

फिर आप इसे पसंद

CompatibleMap<String> map = new CompatibleMap<>(new HashMap<ClassA<String>, ClassB<String>>()); 

इस तरह का दृष्टांत कर सकते हैं, आप एक विशिष्ट Map कार्यान्वयन से जुड़ा नहीं है, और संकलक एक फेंक होगा: आप की तरह निम्नलिखित कुछ कर रही द्वारा इस पर काबू पाने कर सकते हैं त्रुटि अगर map, ClassA और ClassB के सामान्य प्रकार समान नहीं हैं।

Answer 2

आप मानचित्र घोषणा में ऐसा नहीं कर सकते हैं लेकिन आप मानचित्र को एक्सेस/अपडेट करने वाले तरीकों का उपयोग करके ऐसा कर सकते हैं।

उदा।

private final Map<Class, Builder> builderMap = new LinkedHashMap<>(); 

public <T> void addBuilder(Class<T> tClass, Builder<T> tBuilder) { 
    builderMap.put(tClass, tBuilder); 
} 

public <T> Builder<T> getBuilderFor(Class<T> tClass) { 
    @SuppressWarnings("unchecked") 
    Builder<T> tBuilder = (Builder<T>) builderMap.get(tClass); 
    return tBuilder; 
}