उत्पन्न Enums गतिशील रूप

Question

चलो कहते हैं कि मैं एक फ़ाइल जिसका प्रारूप बुनियादी एक्सएमएल है है, तो पसंद आता है:

<?xml version="1.0"?> 
<enum-set> 
    <enum> 
     <name>SomeEnum</name> 
     <values> 
      <value> 
       <name>SOMEVALUE</name> 
       <displayText>This is some value</displayText> 
      </value> 
      ... more values ... 
     </values> 
    </enum> 
    ... more enums ... 
</enum-set> 

और मैं रनटाइम पर कुछ इस तरह में SomeEnum चालू करने के लिए चाहता था:

public enum SomeEnum implements HasDisplayText { 
    SOMEVALUE("This is some value"), 
    ... more values ...; 

    private String displayText; 

    SomeEnum(String displayText) { 
     this.displayText = displayText; 
    } 

    @Override 
    public String getDisplayText() { 
     return displayText; 
    } 
} 

.. और फिर मेरे आवेदन के आस-पास नव निर्मित एनम SomeEnum पास करें। मैं इस तरह कुछ कैसे प्राप्त कर सकता हूं? क्या यह करने योग्य है?

Answer 1

जो आप करने की कोशिश कर रहे हैं वह पूरी तरह से समझ में नहीं आता है। Enums वास्तव में केवल संकलन समय के लाभ के लिए हैं, क्योंकि वे स्थिरांक के एक निश्चित सेट का प्रतिनिधित्व करते हैं। रनटाइम पर, गतिशील रूप से जेनरेट किए गए enum का अर्थ क्या होगा - यह एक सादे वस्तु से अलग कैसे होगा? उदाहरण के लिए:

public class Salutation implements HasDisplayText { 

    private String displayText; 

    private Salutation(String displayText) { 
     this.displayText = displayText; 
    } 

    @Override 
    public String getDisplayText() { 
     return displayText; 
    } 

    public static Collection<Salutation> loadSalutations(String xml) { 
     //parse, instantiate, and return Salutations 
    } 
} 

आपका एक्सएमएल नव instantiated Salutation वस्तुओं, जो कुछ Collection में संग्रहित किया जा सकता है या नहीं तो अपने कार्यक्रम के द्वारा प्रयोग किया में पार्स किया जा सकता है। मेरे उदाहरण में नोटिस, मैंने इसे के निर्माण को private कन्स्ट्रक्टर देकर प्रतिबंधित कर दिया है - इस मामले में उदाहरणों को पुनर्प्राप्त करने का एकमात्र तरीका फ़ैक्टरी विधि को कॉल करना है जो आपका एक्सएमएल लेता है। मेरा मानना ​​है कि यह उस व्यवहार को प्राप्त करता है जिसे आप ढूंढ रहे हैं।

Answer 2

वास्तव में यह गतिशील enum उदाहरणों बनाने के लिए संभव है, लेकिन यह एक कुल हैक है, मैं यह बिल्कुल सलाह नहीं होगा - हो सकता है आप एक enum की प्रकृति गलतफहमी कर रहे हैं, इसके बारे में एक संकलन समय सुविधा है भाषा, और आप रनटाइम पर इसके उदाहरणों को जोड़ने/निकालना नहीं चाहते हैं।

वैसे भी, यदि आप गतिशील रूप से enum उदाहरण बनाने के लिए हैक में रुचि रखते हैं, तो इस article पर एक नज़र डालें।

Answer 3

ऑस्कर लोपेज़ के साथ सहमत हैं। यहां मैंने जो किया है, हैक का एक प्रकार है।

public static enum Setter { 

    DYNAMIC_ENUM_EXAMPLE { 

     @Override 
     public String setGetValue(String yourValue) { 
      return "prefix " + yourValue + " postfix"; 
     } 
    }; 
    public abstract String setGetValue(String value); 
} 

आप इस तरह मूल्य प्राप्त कर सकते हैं:

Setter.DYNAMIC_ENUM_EXAMPLE.setGetValue("namaste") 

आउटपुट:

public abstract class DEnum<E extends DEnum<E>> implements Comparable<E>, Serializable { 

इस वर्ग के होते हैं:

prefix namaste postfix 

Answer 4

गतिशील Enums आपकी समस्या का जवाब है मानक एनयू के समान एक हस्ताक्षर एम कक्षा। कंक्रीट एनम कक्षाओं में उदाहरण निर्माण की अनुमति देने के लिए इसमें संरक्षित कन्स्ट्रक्टर है।उदाहरण के लिए:

YesNo[] items = yes.getItems(); 
assert (items.length == 2); 

यह कर सकते हैं:

String name = YesNo.YES.getName(); 
YesNo yes = YesNo.get(YesNo.class, name); 
assert (yes == YesNo.YES); 

एक टाइप किया गेटर कि सभी वस्तुओं को पुन: प्राप्त नहीं है:

public class YesNo extends DEnum<YesNo> { 

    public final static YesNo YES = new YesNo(); 
    public final static YesNo NO = new YesNo(); 

DEnum वर्ग आत्मनिरीक्षण द्वारा सदस्यों के नाम जानता है रन टाइम पर (डेटाबेस से या फ़ाइल से) गतिशील रूप से सदस्यों को जोड़ें:

YesNo maybe = getOrCreateIfNotExists(YesNo.class, "MAYBE"); 
items = yes.getItems(); 
assert (items.length == 3); 

स्थिर सदस्यों के रूप में एक ही व्यवहार है कौन सा:

YesNo unknown = YesNo.get(YesNo.class, "MAYBE"); 
assert (unknown == maybe);