जावा जेनरिक

Question

का उपयोग करके कुछ मदद की ज़रूरत है, मैं ऑब्जर्वर पैटर्न के समान, मेरे एप्लिकेशन में होने वाली घटनाओं का जवाब देने के लिए एक सिस्टम बनाने की कोशिश कर रहा हूं। अपने सिस्टम में, EventProducer रों ट्रिगर घटनाओं और EventConsumer रों उन घटनाओं पर प्रतिक्रिया दें और दो एक केंद्रीय हब के माध्यम से जुड़े हुए हैं:

पल के लिए, मैं EventProducer ध्यान न दें और EventHub और EventConsumer पर ध्यान केंद्रित करने जा रहा हूँ:

interface EventConsumer<E extends Event> { 
    void respondToEvent(E event); 
} 

class EventHub { 
    private HashMap<Class</*event type*/>, HashSet<EventConsumer</*event type*/>>> subscriptions; 
    public <E extends Event> void fireEvent(E event) { 
     /* For every consumer in the set corresponding to the event type { 
      consumer.respondToEvent(event); 
     } */ 
    } 
    public <E extends Event> void subscribeToEvent(EventConsumer<E> consumer) { 
     /* Insert consumer into the set corresponding to E */ 
    } 
} 

समस्या

HashMap की घोषणा में निहित है: मैं

HashMap<Class<E extends Event>, HashSet<EventConsumer<E>>> 
// or 
<E extends Event> HashMap<Class<E>, HashSet<EventConsumer<E>>> 

की तरह कुछ करने के लिए सक्षम होना चाहते हैं

तो EventConsumer एक ही प्रकार Class है द्वारा parameterized है, लेकिन सबसे करीब मैं प्राप्त कर सकते हैं

HashMap<Class<? extends Event>, HashSet<EventConsumer<? extends Event>>> 

है लेकिन तब यह एक HashSet<EventConsumer<MouseClickEvent>> तरह बातें Class<KeyPressEvent> करने के लिए आवंटित किया जा रहा की अनुमति होगी, दोनों KeyPressEvent और MouseClickEvent उपवर्ग यह सोचते हैं कि Event।

एक दूसरी समस्या subscribeToEvent में है: मैं उपभोक्ता

subscriptions.get(E.class).put(consumer) 

में की तरह, सही सेट अपने घटना के लिए इसी में स्टोर करने के लिए सक्षम होना चाहिए, लेकिन मैं रन-टाइम में ई की श्रेणी नहीं मिल सकता है ।

मैं इन समस्याओं को कैसे हल कर सकता हूं? क्या मैं इस बारे में गलत तरीके से जा रहा हूं?

Answer 1

आप जेनिक्स को EventConsumer कक्षा से निकाल सकते हैं। लेकिन आपको EventConsumer के प्रत्येक कार्यान्वयन में इवेंट ऑब्जेक्ट डालना होगा।

interface EventConsumer { 
    void respondToEvent(Event event); 
} 

class ClickEventConsumer implements EventConsumer { 
    public void respondToEvent(Event event){ 
    ClickEvent ce = (ClickEvent)event; 
    //... 
    } 
} 

class EventHub { 
    private HashMap<Class<? extends Event>, HashSet<EventConsumer>> subscriptions; 

    public void fireEvent(Event event) { 
    HashSet<EventConsumer> consumers = subscriptions.get(event.getClass()); 
    if (consumers != null){ 
     for (EventConsumer ec : consumers){ 
     ec.respondToEvent(event); 
     } 
    } 
    } 

    public void subscribeToEvent(Class<? extends Event> clazz, EventConsumer consumer) { 
    HashSet<EventConsumer> consumers = subscriptions.get(clazz); 
    if (consumers == null){ 
     consumers = new HashSet<EventConsumer>(); 
     subscriptions.put(clazz, consumers); 
    } 
    consumers.add(consumer); 
    } 
} 

Answer 2

मानचित्र का सवाल है, मैं इसे इस रूप में छोड़ चाहते हैं:

HashMap<Class<? extends Event>, Set<EventConsumer<? extends Event>>> subscriptions; 

और फिर जैसे पैरामिट्रीकृत एक्सेसर तरीकों का उपयोग:

<E extends Event> void addSubscription(Class<E> eventClass, EventConsumer<? super E> eventConsumer) 

<E extends Event> Set<EventConsumer<? super E>> getSubscriptions(Class<E> eventClass) 

के रूप में आप पहले ही बताया आप घटना वर्ग प्राप्त नहीं कर सकता रनटाइम पर, इसलिए आपको इसे अपने एपीआई उपयोगकर्ताओं द्वारा प्रदान किया जाना होगा उदाहरण के लिए ऊपर दिए गए addSubscription के विधि हस्ताक्षर के साथ।

Answer 3

आप अपने EventHub क्लास को पैरामीटर क्यों नहीं करते? कोई चुनौती?

interface EventConsumer<E extends Event> { 
void respondToEvent(E event); 
} 

class EventHub<E extends Event> { 
private HashMap<Class<E>, HashSet<EventConsumer<E>>> subscriptions; 

public void fireEvent(E event) { 
/* 
* For every consumer in the set corresponding to the event type { 
* consumer.respondToEvent(event); } 
*/ 
    } 

    public void subscribeToEvent(EventConsumer<E> consumer) { 
    /* Insert consumer into the set corresponding to E */ 
} 
} 

और फिर अपने सभी फ़ंक्शन हस्ताक्षरों में ई का उपयोग करें।

संपादित करें 1: ठीक है, के बाद से मैं और अधिक स्पष्ट रूप में अपने प्रश्न को समझते हैं, यहाँ हम चले:

अपने EventConsumer कक्षा एक EventType (रों) है कि यह समर्थन करता है/हैंडल रख सकते हैं। यहां तक ​​कि टाइप एक enum है। अपने मानचित्र में आप उपभोक्ता को इवेंट टाइप के खिलाफ स्टोर करते हैं।

Answer 4

आप क्या कर सकते हैं मानचित्र को अपने स्वयं के पैरामीटरयुक्त वर्ग के साथ लपेटना है। कक्षा में पैरामीटर दिया - आप इसे मानचित्र में उपयोग कर सकते हैं।ऐसा ही कुछ:

public class EventsMap<E extends Event> { 
    HashMap<Class<E>, HashSet<E>> map; 
} 

सदस्यता लेने के लिए के रूप में - मैं ty1824 के जवाब का उपयोग करेंगे ..

Answer 5

खैर, अंत से शुरू:

सबसे पहले, आप वास्तव में कार्यावधि में सामान्य प्रकार पैरामीटर प्रकार प्राप्त कर सकते हैं । यह सिर्फ है कि आप केवल एक विशेष मामले में यह क्या कर सकते हैं:

static class A<E extends EventObject> { 
} 

static class B extends A<MouseEvent> { 
} 

public static void main(String[] args) { 
    System.out.println(B.class.getGenericSuperclass()); 
} 

नोट B गैर सामान्य है, लेकिन एक सामान्य माता पिता से विरासत में मिला है।

सुपर क्लास एक पैरामिट्रीकृत प्रकार है, तो Type वस्तु लौटे सही रूप में वास्तविक प्रकार स्रोत कोड में प्रयोग किया जाता मानकों प्रतिबिंबित करना चाहिए।

चाहे आप इसे किसी भी प्रयोग में डाल सकते हैं, एक अलग सवाल है। मैंने कोशिश नहीं की मैंने जो कोड देखा है, वह स्पष्ट रूप से Class उदाहरण को वर्कअराउंड के रूप में पास करता है।

दूसरा, Map यहां नहीं है (ठीक है, जहां तक ​​मुझे पता है) जेनेरिक के साथ तय किया जा सकता है। आप निश्चित रूप से एक टाइपएफ़ मैप लागू कर सकते हैं, लेकिन मुझे लगता है कि एक और दिलचस्प बात यह है कि: जब आप किसी ईवेंट को फायर करते हैं, तो संभवतः आप इसे इस विशेष ईवेंट क्लास और पर सब्सक्राइब करने वाले सभी को भेजना चाहते हैं, जिन्होंने अपने माता-पिता की सदस्यता ली है । तो बस event.getClass() पर्याप्त से थोड़ा कम होगा।