एनम क्या हैं और वे क्यों उपयोगी हैं?


488

आज मैं इस साइट पर कुछ सवालों के माध्यम से ब्राउज़ कर रहा था और मुझे इस तरह के समाधान के लिए कथित सुरक्षा के लाभ के बारे enum में सिंगलटन पैटर्न में इस्तेमाल होने का उल्लेख मिला ।

मैंने कभी भी enumएस का उपयोग नहीं किया है और मैं कुछ वर्षों से अधिक समय से जावा में प्रोग्राम कर रहा हूं। और जाहिर है वे बहुत बदल गए। अब वे अपने भीतर ओओपी का पूर्ण समर्थन भी करते हैं।

अब मुझे दिनभर की प्रोग्रामिंग में एनम का उपयोग क्यों और किस लिए करना चाहिए?


6
अपनी पुस्तक इफेक्टिव जावा, द्वितीय संस्करण में , जोशुआ बलोच आइटम 3 में इस दृष्टिकोण पर विस्तार से बताते हैं : एक निजी कंस्ट्रक्टर के साथ सिंगलटन संपत्ति को लागू करें या डॉ। डॉब में पुनर्मुद्रित एक टाइप करें
त्रशगोद


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

जवाबों:


633

आपको हमेशा एनम का उपयोग करना चाहिए जब एक चर (विशेष रूप से एक विधि पैरामीटर) संभव मूल्यों के एक छोटे से सेट में से केवल एक निकाल सकता है। उदाहरण प्रकार स्थिरांक (अनुबंध की स्थिति: "स्थायी", "अस्थायी", "अपरेंटिस"), या झंडे ("अब निष्पादित करें", "निष्कासन निष्पादन") जैसी चीजें होंगी।

यदि आप पूर्णांक (या स्ट्रिंग कोड) के बजाय एनम का उपयोग करते हैं, तो आप संकलन-समय की जाँच बढ़ाते हैं और अमान्य स्थिरांक में पारित होने से त्रुटियों से बचते हैं, और आप दस्तावेज़ का उपयोग करते हैं कि कौन से मूल्य कानूनी हैं।

बीटीडब्ल्यू, एनम के अति प्रयोग का मतलब यह हो सकता है कि आपके तरीके बहुत अधिक हैं (यह अक्सर कई अलग-अलग तरीकों से बेहतर होता है, बजाय एक विधि के जो कई झंडे लगाता है जो इसे संशोधित करता है), लेकिन अगर आपको झंडे या प्रकार कोड का उपयोग करना है, तो एनम जाने का रास्ता है।

एक उदाहरण के रूप में, जो बेहतर है?

/** Counts number of foobangs.
 * @param type Type of foobangs to count. Can be 1=green foobangs,
 * 2=wrinkled foobangs, 3=sweet foobangs, 0=all types.
 * @return number of foobangs of type
 */
public int countFoobangs(int type)

बनाम

/** Types of foobangs. */
public enum FB_TYPE {
 GREEN, WRINKLED, SWEET, 
 /** special type for all types combined */
 ALL;
}

/** Counts number of foobangs.
 * @param type Type of foobangs to count
 * @return number of foobangs of type
 */
public int countFoobangs(FB_TYPE type)

एक विधि कॉल की तरह:

int sweetFoobangCount = countFoobangs(3);

फिर बन जाता है:

int sweetFoobangCount = countFoobangs(FB_TYPE.SWEET);

दूसरे उदाहरण में, यह तुरंत स्पष्ट है कि किस प्रकार की अनुमति है, डॉक्स और कार्यान्वयन सिंक से बाहर नहीं जा सकते हैं, और कंपाइलर इसे लागू कर सकता है। इसके अलावा, एक अवैध कॉल की तरह

int sweetFoobangCount = countFoobangs(99);

अब संभव नहीं है।


41
यदि आप enums का उपयोग करते हैं और मूल्यों के संयोजन की अनुमति देना चाहते हैं, तो EnumSet का उपयोग करें। यह सभी प्रकार के साफ-सुथरे सहायकों के साथ आता है, जैसे सार्वजनिक स्थैतिक अंतिम EnumSet <FB_TYPE> ALL = EnumSet.allOf (FB_TYPE.class);
राबाउ

20
ये उत्तर वे हैं जिन्हें मैं वास्तव में एसओ में देखना पसंद करता हूं क्योंकि किसी ने इसमें कुछ वास्तविक प्रयास किया है, अच्छी नौकरी जिसे मैं अब समझ रहा हूं!
डेडिकेटेड

1
मुझे नहीं लगता कि यह सच है you should *always* use enums when a variable can only take one out of a small set of possible values। 'बाइनरी फ्लैग' (तार्किक orआईएनजी के साथ ) के रूप में निरंतर मूल्यों का उपयोग करना वास्तविक समय अनुप्रयोगों के लिए उपयोगी हो सकता है जहां आप स्मृति में कम हैं।
२१

@ Enums का उपयोग करने से आपके कोड की पठनीयता बढ़ जाती है, यदि आप किसी समय या आपके उत्तराधिकारी का उपयोग निरंतरता से करते हैं तो आपको यह पता नहीं है कि इसका उपयोग क्यों किया जाता है ...
:)

136

किसी भी प्रोग्रामिंग भाषा सुविधा का उपयोग क्यों करें? हमारे पास सभी भाषाओं का कारण है

  1. प्रोग्रामर कुशलतापूर्वक और सही ढंग से एल्गोरिदम को एक रूप में व्यक्त कर सकते हैं जो कंप्यूटर उपयोग कर सकते हैं।
  2. एल्गोरिदम को समझने के लिए अन्य लोगों ने लिखा है और सही ढंग से परिवर्तन करते हैं।

एनामल बहुत सारे बॉयलरप्लेट लिखे बिना शुद्धता और पठनीयता दोनों की संभावना में सुधार करते हैं। यदि आप बॉयलरप्लेट लिखने के इच्छुक हैं, तो आप "अनुकरण" कर सकते हैं:

public class Color {
    private Color() {} // Prevent others from making colors.
    public static final Color RED = new Color();
    public static final Color AMBER = new Color();
    public static final Color GREEN = new Color();
}

अब आप लिख सकते हैं:

Color trafficLightColor = Color.RED;

ऊपर दिए गए बॉयलरप्लेट का उतना ही प्रभाव है जितना कि

public enum Color { RED, AMBER, GREEN };

दोनों कंपाइलर से मदद के समान स्तर की जाँच प्रदान करते हैं। बॉयलरप्लेट सिर्फ अधिक टाइपिंग है। लेकिन बहुत अधिक टाइपिंग को सहेजना प्रोग्रामर को अधिक कुशल बनाता है (देखें 1), इसलिए यह एक सार्थक विशेषता है।

यह कम से कम एक और कारण के लिए भी सार्थक है:

स्टेटमेंट स्विच करें

एक बात जो static finalऊपर एनम सिमुलेशन आपको नहीं देता है वह अच्छे switchमामले हैं। Enum प्रकारों के लिए, Java स्विच अपने वैरिएबल के प्रकार का उपयोग करता है ताकि एनम मामलों के दायरे का अनुमान लगाया जा सके, इसलिए enum Colorउपरोक्त के लिए आप केवल यह कहना चाहते हैं:

Color color = ... ;
switch (color) {
    case RED:
        ...
        break;
}

ध्यान दें कि यह Color.REDमामलों में नहीं है। यदि आप एनम का उपयोग नहीं करते हैं, तो नामांकित मात्रा का उपयोग करने का एकमात्र तरीका switchकुछ इस प्रकार है:

public Class Color {
    public static final int RED = 0;
    public static final int AMBER = 1;
    public static final int GREEN = 2;
}

लेकिन अब एक रंग धारण करने के लिए एक चर प्रकार होना चाहिए int। Enum और static finalसिमुलेशन की अच्छी संकलक जाँच हो गई है। खुश नहीं।

एक सिमुलेशन में एक स्केलर-मूल्यवान सदस्य का उपयोग करना है:

public class Color {
    public static final int RED_TAG = 1;
    public static final int AMBER_TAG = 2;
    public static final int GREEN_TAG = 3;

    public final int tag;

    private Color(int tag) { this.tag = tag; } 
    public static final Color RED = new Color(RED_TAG);
    public static final Color AMBER = new Color(AMBER_TAG);
    public static final Color GREEN = new Color(GREEN_TAG);
}

अभी:

Color color = ... ;
switch (color.tag) {
    case Color.RED_TAG:
        ...
        break;
}

लेकिन ध्यान दें, और भी अधिक बॉयलरप्लेट!

एक Enum का उपयोग एक सिंगलटन के रूप में करना

ऊपर बॉयलरप्लेट से आप देख सकते हैं कि क्यों एक एनम एक सिंगलटन को लागू करने का एक तरीका प्रदान करता है। लिखने के बजाय:

public class SingletonClass {
    public static final void INSTANCE = new SingletonClass();
    private SingletonClass() {}

    // all the methods and instance data for the class here
}

और फिर इसके साथ पहुँच

SingletonClass.INSTANCE

हम सिर्फ कह सकते हैं

public enum SingletonClass {
    INSTANCE;

    // all the methods and instance data for the class here
}

जो हमें वही चीज देता है। हम इससे दूर हो सकते हैं क्योंकि जावा एनम को पूर्ण कक्षाओं के रूप में कार्यान्वित किया जाता है, जिसमें केवल थोड़ा सा सिन्क्रेटिक चीनी शीर्ष पर छिड़का जाता है। यह फिर से कम बॉयलर है, लेकिन यह तब तक गैर-स्पष्ट है जब तक कि मुहावरा आपसे परिचित नहीं है। मैं इस तथ्य को भी नापसंद करता हूं कि आपको विभिन्न एनम फ़ंक्शंस प्राप्त होते हैं, भले ही वे सिंगलटन के लिए बहुत अर्थ नहीं रखते हैं: ordऔर values, आदि (वास्तव में एक ट्रिकियर सिमुलेशन है जहां Color extends Integerस्विच के साथ काम होगा, लेकिन यह इतना मुश्किल है कि यह और भी अधिक हो जाए स्पष्ट रूप से पता चलता है कि enumबेहतर विचार क्यों है।)

धागा सुरक्षा

थ्रेड सेफ्टी एक संभावित समस्या है, जब केवल एकल लॉकिंग के साथ ही लैजेटली बनाया जाता है।

public class SingletonClass {
    private static SingletonClass INSTANCE;
    private SingletonClass() {}
    public SingletonClass getInstance() {
        if (INSTANCE == null) INSTANCE = new SingletonClass();
        return INSTANCE;
    }

    // all the methods and instance data for the class here
}

यदि कई धागे getInstanceएक साथ कॉल करते हैं जबकि INSTANCEअभी भी अशक्त है, तो किसी भी संख्या में उदाहरण बनाए जा सकते हैं। ये गलत है। एकमात्र उपाय synchronizedचर की रक्षा के लिए उपयोग जोड़ना है INSTANCE

हालाँकि, static finalऊपर दिए गए कोड में यह समस्या नहीं है। यह क्लास लोड समय पर उत्सुकता से उदाहरण बनाता है। वर्ग लोडिंग सिंक्रनाइज़ है।

enumसिंगलटन प्रभावी रूप से आलसी, क्योंकि यह पहला प्रयोग है जब तक प्रारंभ नहीं किया गया है। जावा इनिशियलाइज़ेशन भी सिंक्रनाइज़ है, इसलिए कई थ्रेड्स एक से अधिक इंस्टेंस को इनिशियलाइज़ नहीं कर सकते हैं INSTANCE। आपको बहुत कम कोड के साथ एक आलसी प्रारंभिक सिंगनलटन मिल रहा है। केवल नकारात्मक बल्कि अस्पष्ट वाक्यविन्यास है। आपको मुहावरा जानने या अच्छी तरह से समझने की जरूरत है कि क्लास लोडिंग और इनिशियलाइज़ेशन कैसे काम करता है, यह जानने के लिए।


15
पिछले पैराग्राफ ने वास्तव में मेरे लिए सिंगलटन स्थिति स्पष्ट कर दी थी। धन्यवाद! जो भी पाठक स्किमिंग कर रहा है, उसे फिर से पढ़ना चाहिए।
बेसिल बॉर्क

मैं इसे पढ़ रहा था, stackoverflow.com/questions/16771373/… । अब मैं आपके आखिरी पैरा से उलझन में हूं। कैसे एनूम नॉट लेट इनिशियलाइज़ेशन फीचर प्रदान करता है?
दीपंकर सिंह

static finalफ़ील्ड को क्लास इनिशियलाइज़ेशन समय पर आरम्भ किया जाता है , लोडिंग समय नहीं। यह enumनिरंतर आरंभीकरण के साथ बिल्कुल वैसा ही है (वास्तव में, वे हुड के नीचे समान हैं)। यही कारण है कि एकल के लिए "चतुर" आलसी आरंभीकरण कोड को लागू करने की कोशिश करना हमेशा व्यर्थ था, यहां तक ​​कि पहले जावा संस्करण में भी।
होल्गर

42

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

  1. कोड होने से जहां डेटा है (जो कि एनम के भीतर है - या अक्सर एनम कॉन्स्टेंट के भीतर, जो विधियों को ओवरराइड कर सकता है)।
  2. क्लाइंट कोड को एनम (जो केवल डिफ़ॉल्ट कार्यान्वयन का एक सेट प्रदान करना चाहिए) को बाध्य नहीं करने के लिए एक इंटरफ़ेस (या अधिक) लागू करना।

सबसे सरल उदाहरण Comparatorकार्यान्वयन का एक सेट होगा :

enum StringComparator implements Comparator<String> {
    NATURAL {
        @Override
        public int compare(String s1, String s2) {
            return s1.compareTo(s2);
        }
    },
    REVERSE {
        @Override
        public int compare(String s1, String s2) {
            return NATURAL.compare(s2, s1);
        }
    },
    LENGTH {
        @Override
        public int compare(String s1, String s2) {
            return new Integer(s1.length()).compareTo(s2.length());
        }
    };
}

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

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


2
आप भी जोड़ सकते हैं CASE_INSENSITIVE { @Override public int compare(String s1, String s2) { return s1.compareToIgnoreCase(s2); }। अभी तक उल्लेख नहीं किया गया एक लाभ यह है कि आपको एक मजबूत सीरियललाइज़ेशन समर्थन मिलता है; निरंतर रूप में केवल वर्ग का नाम और निरंतर नाम होता है, न कि आपके समकक्षों के कार्यान्वयन के विवरण पर निर्भर करता है।
होल्गर

32

कुछ अन्य उत्तरों में से कोई भी कवर नहीं किया गया है जो विशेष रूप से शक्तिशाली हैं, जो टेम्पलेट विधियों की क्षमता रखते हैं । विधियाँ आधार एनुम का हिस्सा हो सकती हैं और प्रत्येक प्रकार से ओवरराइड की जा सकती हैं। और, एनम के साथ जुड़े व्यवहार के साथ, यह अक्सर इस ब्लॉग पोस्ट को प्रदर्शितenum.method() करता है कि क्या -और निर्माण या स्विच स्टेटमेंट की आवश्यकता को समाप्त करता है - जहां मूल रूप से सशर्त के अंदर निष्पादित किया जाएगा। उसी उदाहरण से पता चलता है कि एनम के साथ स्थिर आयात का उपयोग कोड के साथ बहुत क्लीनर डीएसएल का उत्पादन करता है।

कुछ अन्य रोचक तथ्य यह है कि गुणों enums के लिए कार्यान्वयन प्रदान शामिल हैं equals(), toString()और hashCode()और लागू Serializableऔर Comparable

इन सभी बातों का एक पूरा विस्तृत विवरण देने के लिए, मुझे जावा 4 वें संस्करण में ब्रूस एकेल की सोच की अत्यधिक अनुशंसा करनी होगी, जो विषय के एक पूरे अध्याय को समर्पित करता है। विशेष रूप से प्रबुद्ध एक रॉक, पेपर, कैंची (यानी RoShamBo) खेल में शामिल हैं उदाहरण हैं।


23

जावा दस्तावेजों से -

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

एक सामान्य उदाहरण एक स्थिर प्रकार के साथ निजी स्थिर अंतिम इंट कॉन्स्टेंट (स्थिरांक की उचित संख्या के भीतर) के एक वर्ग को बदलने के लिए है। मूल रूप से अगर आपको लगता है कि आप संकलन समय पर "कुछ" के सभी संभावित मूल्यों को जानते हैं तो आप इसे एक एनम प्रकार के रूप में दर्शा सकते हैं। Enums स्थिरांक के साथ एक वर्ग पर पठनीयता और लचीलापन प्रदान करते हैं।

कुछ अन्य फायदे जो मैं एनम प्रकारों के बारे में सोच सकता हूं। वे हमेशा एक विशेष एनुम वर्ग का एक उदाहरण होते हैं (इसलिए सिंगल्स के रूप में एनम का उपयोग करने की अवधारणा आती है)। एक और फायदा यह है कि आप स्विच-केस स्टेटमेंट में एक प्रकार के रूप में एनम का उपयोग कर सकते हैं। इसके अलावा, आप उन्हें पढ़ने योग्य तार के रूप में मुद्रित करने के लिए enum पर toString () का उपयोग कर सकते हैं ।


8
क्या आप वर्ष में सभी 366 दिनों के लिए एक एनम का उपयोग करेंगे? यह स्थिरांक का एक निश्चित सेट (366) है (दिन नहीं बदल रहे हैं)। तो यह सुझाव आपको चाहिए। : - / मैं निर्धारित सेट के आकार को बाधित करता हूं।
मोइनुद्दीन

2
@ स्मार्टकॉग थोड़ी चतुर सोच के साथ एक कॉम्पैक्ट एनम में प्रत्येक महीने में एक सप्ताह और दिनों के दिनों को संक्षेप में प्रस्तुत करना संभव हो सकता है।
जेम्स पी।

1
सप्ताह के दिनों की बात करें ... DayOfWeekenum अब पूर्व-परिभाषित है, जावा 8 में बनाया गया है और बाद में java.time फ्रेमवर्क के हिस्से के रूप में (और जावा 6 और 7 और एंड्रॉइड के लिए वापस पोर्ट किया गया है )।
il:

19

अब मुझे दिनभर की प्रोग्रामिंग में एनम का उपयोग क्यों और किस लिए करना चाहिए?

पठनीयता बढ़ाने के दौरान आप स्थिरांक या आंतरिक कक्षा मोड के छोटे से निर्धारित समूह का प्रतिनिधित्व करने के लिए एनम का उपयोग कर सकते हैं। इसके अलावा, एनम विधि पद्धति में उपयोग किए जाने पर एक निश्चित कठोरता को लागू कर सकती है। वे ओरेकल की साइट पर ग्रहों के उदाहरण की तरह एक निर्माणकर्ता को जानकारी देने की दिलचस्प संभावना प्रदान करते हैं और, जैसा कि आपने खोजा है, एक सिंगलटन पैटर्न बनाने का एक सरल तरीका भी अनुमति देता है।

उदाहरण के लिए: Locale.setDefault(Locale.US) बेहतर पढ़ता है Locale.setDefault(1)और जब आप .सभी पूर्णांकों के बजाय विभाजक जोड़ते हैं, तो एक IDE में दिखाए गए मानों के निश्चित सेट के उपयोग को लागू करता है ।


@ इस सवाल में मैंने व्याकरण भी तय कर दिया है। धन्यवाद।
जेम्स पी।

13

Enums स्व-दस्तावेजीकरण के तरीके में, मूल्यों का एक निश्चित समूह गणना करें।
वे आपके कोड को अधिक स्पष्ट करते हैं, और त्रुटि-प्रवण भी कम होते हैं।

स्थिरांक के लिए String, या intइसके बजाय , का उपयोग क्यों नहीं Enumकिया जाता है?

  1. कंपाइलर टाइपो को अनुमति नहीं देगा , न ही निर्धारित सेट से मानों को, क्योंकि एनम स्वयं के प्रकार हैं। परिणाम:
    • अपने तर्क को मान्य सीमा में होने का आश्वासन देने के लिए आपको कोई पूर्व शर्त (या मैनुअल if) नहीं लिखनी होगी ।
    • प्रकार अपरिवर्तनीय मुक्त करने के लिए आता है।
  2. एनमों का व्यवहार हो सकता है, किसी अन्य वर्ग की तरह।
  3. आपको संभवतः Stringएस का उपयोग करने के लिए समान मात्रा में मेमोरी की आवश्यकता होगी , वैसे भी (यह जटिलता पर निर्भर करता है Enum)।

इसके अलावा, प्रत्येक Enumउदाहरण एक वर्ग है, जिसके लिए आप इसके व्यक्तिगत व्यवहार को परिभाषित कर सकते हैं।

इसके अलावा, वे उदाहरणों के निर्माण पर थ्रेड सुरक्षा का आश्वासन देते हैं (जब एनम को लोड किया जाता है), जिसने सिंगिंग पैटर्न को सरल बनाने में महान आवेदन देखा है ।

यह ब्लॉग अपने कुछ अनुप्रयोगों को दिखाता है, जैसे कि एक पार्सर के लिए एक स्टेट मशीन


13

यह जानना उपयोगी है कि खेतों के enumsसाथ अन्य वर्गों की तरह Constantहैं और एprivate constructor

उदाहरण के लिए,

public enum Weekday
{
  MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
} 

संकलक इसे निम्नानुसार संकलित करता है;

class Weekday extends Enum
{
  public static final Weekday MONDAY  = new Weekday( "MONDAY",   0 );
  public static final Weekday TUESDAY = new Weekday( "TUESDAY ", 1 );
  public static final Weekday WEDNESDAY= new Weekday( "WEDNESDAY", 2 );
  public static final Weekday THURSDAY= new Weekday( "THURSDAY", 3 );
  public static final Weekday FRIDAY= new Weekday( "FRIDAY", 4 );
  public static final Weekday SATURDAY= new Weekday( "SATURDAY", 5 );
  public static final Weekday SUNDAY= new Weekday( "SUNDAY", 6 );

  private Weekday( String s, int i )
  {
    super( s, i );
  }

  // other methods...
}

12

enumमतलब एनुम आयन यानी एक के बाद एक (कई चीजों का) जिक्र।

एक enum है जिसमें स्थिरांक का सेट स्थायी एक डेटा प्रकार है।

या

एक enumबस एक की तरह है classसंकलन समय पर जाना जाता उदाहरणों की एक निश्चित सेट के साथ,।

उदाहरण के लिए:

public class EnumExample {
    interface SeasonInt {
        String seasonDuration();
    }

    private enum Season implements SeasonInt {
        // except the enum constants remaining code looks same as class
        // enum constants are implicitly public static final we have used all caps to specify them like Constants in Java
        WINTER(88, "DEC - FEB"), SPRING(92, "MAR - JUN"), SUMMER(91, "JUN - AUG"), FALL(90, "SEP - NOV");

        private int days;
        private String months;

        Season(int days, String months) { // note: constructor is by default private 
            this.days = days;
            this.months = months;
        }

        @Override
        public String seasonDuration() {
            return this+" -> "+this.days + "days,   " + this.months+" months";
        }

    }
    public static void main(String[] args) {
        System.out.println(Season.SPRING.seasonDuration());
        for (Season season : Season.values()){
            System.out.println(season.seasonDuration());
        }

    }
}

फिटकरी के फायदे:

  • enum रन-टाइम में त्रुटियों से बचने के लिए संकलन-समय पर जाँच में सुरक्षा को बेहतर बनाता है।
  • Enum को स्विच में आसानी से इस्तेमाल किया जा सकता है
  • एनम का पता लगाया जा सकता है
  • enum में फ़ील्ड, कंस्ट्रक्टर और विधियाँ हो सकती हैं
  • enum कई इंटरफेस को लागू कर सकता है लेकिन किसी भी वर्ग का विस्तार नहीं कर सकता क्योंकि यह आंतरिक रूप से Enum वर्ग का विस्तार करता है

के लिए और अधिक


9

एक एनम क्या है

  • enum Enumeration एक नया डेटा प्रकार के लिए परिभाषित कीवर्ड है। टाइपफोर एन्यूमरेशंस को उदारतापूर्वक उपयोग किया जाना चाहिए। विशेष रूप से, वे संबंधित वस्तुओं के सेट का प्रतिनिधित्व करने के लिए बहुत पुराने एपीआई में उपयोग किए जाने वाले सरल स्ट्रिंग या इंट कॉन्स्टेंट का एक मजबूत विकल्प हैं।

एनम का उपयोग क्यों करें

  • enums संक्षेप में java.lang.Enum के अंतिम उपवर्ग हैं
  • यदि एक एनम एक वर्ग का सदस्य है, तो यह स्पष्ट रूप से स्थिर है
  • नए का उपयोग एनम के साथ कभी नहीं किया जा सकता है, यहां तक ​​कि एनम प्रकार के भीतर भी
  • नाम और मान यदि केवल एनम स्थिरांक के पाठ का उपयोग करते हैं, जबकि यदि वांछित हो तो किसी भी सामग्री को प्रदान करने के लिएस्ट्रिंग को ओवरराइड किया जा सकता है
  • समरूप स्थिरांक के लिए, एक ही चीज़ के बराबर और == राशि होती है, और इसे परस्पर उपयोग किया जा सकता है
  • Enum स्थिरांक स्पष्ट रूप से सार्वजनिक स्थैतिक फाइनल हैं

ध्यान दें

  • एनम किसी भी वर्ग का विस्तार नहीं कर सकते हैं।
  • एक एनम एक सुपरक्लास नहीं हो सकता।
  • एनम स्थिरांक की उपस्थिति के क्रम को उनका "प्राकृतिक क्रम" कहा जाता है, और अन्य वस्तुओं द्वारा उपयोग किए जाने वाले आदेश को भी परिभाषित करता है: तुलना, मूल्यों के पुनरावृत्ति क्रम, एनुसेट, एनुमसेट। अरेंज।
  • एक एन्यूमरेशन में कंस्ट्रक्टर, स्टैटिक और इंस्टेंस ब्लॉक, वैरिएबल और मेथड हो सकते हैं लेकिन एब्सट्रैक्ट मेथड नहीं हो सकते।

4
आप यह नहीं समझाते कि एनम का उपयोग क्यों करना है। आप बस असंबंधित हेडर के तहत एनम के कई गुणों को सूचीबद्ध करते हैं।
डंकन जोन्स

@DuncanJones शब्दों को अंतिम रूप नहीं देता, स्थैतिक का उपयोग करने का उद्देश्य देता है?
tinker_fairy

8

दूसरों के द्वारा कहा गया सब के अलावा .. एक पुराने प्रोजेक्ट में, जिसके लिए मैं काम करता था, संस्थाओं (स्वतंत्र अनुप्रयोगों) के बीच बहुत सारे संचार पूर्णांकों का उपयोग कर रहे थे जो एक छोटे से सेट का प्रतिनिधित्व करते थे। ऑब्जेक्ट enumको स्थिर करने के लिए स्टैटिक विधियों के साथ सेट घोषित करना उपयोगी था । कोड क्लीनर को देखा, लॉग करने के लिए केस प्रयोज्य और आसान लेखन स्विच किया।enumvalue

enum ProtocolType {
    TCP_IP (1, "Transmission Control Protocol"), 
    IP (2, "Internet Protocol"), 
    UDP (3, "User Datagram Protocol");

    public int code;
    public String name;

    private ProtocolType(int code, String name) {
        this.code = code;
        this.name = name;
    }

    public static ProtocolType fromInt(int code) {
    switch(code) {
    case 1:
        return TCP_IP;
    case 2:
        return IP;
    case 3:
        return UDP;
    }

    // we had some exception handling for this
    // as the contract for these was between 2 independent applications
    // liable to change between versions (mostly adding new stuff)
    // but keeping it simple here.
    return null;
    }
}

enumप्राप्त मानों (जैसे 1,2) से ऑब्जेक्ट बनाएं, लिखकर ProtocolType.fromInt(2) लॉग्स का उपयोग करेंmyEnumObj.name

उम्मीद है की यह मदद करेगा।


6

Enum को Objectक्लास और एब्स्ट्रैक्ट क्लास के सभी तरीके विरासत में मिलते हैं Enum। तो आप इसे प्रतिबिंब, मल्टीथ्रेडिंग, सीरीज़ेशन, तुलनीय, आदि के लिए उपयोग कर सकते हैं। यदि आप Enum के बजाय एक स्थिर स्थिरांक की घोषणा करते हैं, तो आप नहीं कर सकते। इसके अलावा, Enum का मान DAO परत को भी पारित किया जा सकता है।

यहां एक उदाहरण कार्यक्रम प्रदर्शित करना है।

public enum State {

    Start("1"),
    Wait("1"),
    Notify("2"),
    NotifyAll("3"),
    Run("4"),
    SystemInatilize("5"),
    VendorInatilize("6"),
    test,
    FrameworkInatilize("7");

    public static State getState(String value) {
        return State.Wait;
    }

    private String value;
    State test;

    private State(String value) {
        this.value = value;
    }

    private State() {
    }

    public String getValue() {
        return value;
    }

    public void setCurrentState(State currentState) {
        test = currentState;
    }

    public boolean isNotify() {
        return this.equals(Notify);
    }
}

public class EnumTest {

    State test;

    public void setCurrentState(State currentState) {
        test = currentState;
    }

    public State getCurrentState() {
        return test;
    }

    public static void main(String[] args) {
        System.out.println(State.test);
        System.out.println(State.FrameworkInatilize);
        EnumTest test=new EnumTest();
        test.setCurrentState(State.Notify);
        test. stateSwitch();
    }

    public void stateSwitch() {
        switch (getCurrentState()) {
        case Notify:
            System.out.println("Notify");
            System.out.println(test.isNotify());
            break;
        default:
            break;
        }
    }
}

4

Enum का अर्थ "Enumerated Type" है। यह एक डेटा प्रकार है जिसमें स्थिरांक का एक निश्चित समूह होता है जिसे आप स्वयं परिभाषित करते हैं।


आपने समझाया नहीं है कि एनम का उपयोग क्यों करना है।
डंकन जोन्स

4
हाँ, मैंने किया। आप इसका उपयोग स्थिरांक के एक निश्चित सेट को संग्रहीत करने के लिए करते हैं जिसे आप स्वयं परिभाषित करते हैं। इसका विशिष्ट अनुप्रयोग आपके ऊपर है। कब, क्यों, या किसी चीज़ का उपयोग कैसे करना है जैसी कोई बात नहीं है। यह डेवलपर की जरूरतों पर निर्भर है। आपको बस यह समझने की जरूरत है कि यह क्या है और यह कैसे काम करता है।
स्टीव

4

मेरी राय में, अब तक आपके द्वारा प्राप्त सभी उत्तर मान्य हैं, लेकिन मेरे अनुभव में, मैं इसे कुछ शब्दों में व्यक्त करूंगा:

यदि आप चाहते हैं कि किसी पहचानकर्ता के मूल्य की वैधता की जांच करने के लिए एनम का उपयोग करें।

अन्यथा, आप हमेशा की तरह स्ट्रिंग्स का उपयोग कर सकते हैं (शायद आपने अपने आवेदन के लिए कुछ "सम्मेलनों" को परिभाषित किया है) और आप बहुत लचीले होंगे ... लेकिन आपको अपने स्ट्रिंग्स पर टाइपोस के खिलाफ 100% सुरक्षा नहीं मिलेगी और आप उन्हें केवल महसूस करेंगे क्रम में।


3

TYPE SAFETY के लिए enums का उपयोग करें, यह एक भाषा की विशेषता है जिससे आपको आमतौर पर मिलेगा:

  • संकलक समर्थन (तुरंत प्रकार के मुद्दों को देखें)
  • आईडीई में टूल सपोर्ट (स्विच केस में ऑटो-कम्पलीट, मिसिंग केस, फोर्स डिफॉल्ट, ...)
  • कुछ मामलों में enum प्रदर्शन भी महान (है EnumSet , पारंपरिक पूर्णांक आधारित करने के लिए typesafe विकल्प "बिट झंडे।" )

Enums में विधियाँ, निर्माता हो सकते हैं, आप enums के अंदर भी enums का उपयोग कर सकते हैं और इंटरफेस के साथ enums जोड़ सकते हैं।

इंटम कॉन्स्टेंट के एक अच्छी तरह से परिभाषित सेट (जो C / C ++ से जावा को विरासत में मिला है) को बदलने के लिए और कुछ मामलों में बिट्स को बदलने के लिए कुछ प्रकार के एनम के बारे में सोचें।

प्रभावी जावा 2 संस्करण की पुस्तक में उनके बारे में एक पूरा अध्याय है और अधिक विवरण में जाता है। इस स्टैक ओवरफ्लो पोस्ट को भी देखें ।


2

जावा आपको केवल कुछ पूर्वनिर्धारित मूल्यों में से एक होने के लिए चर को प्रतिबंधित करने देता है - दूसरे शब्दों में, एन्यूमरेटेड सूची से एक मूल्य। उपयोग enumsकरने से आपके कोड में बग को कम करने में मदद मिल सकती है। यहाँ enumsएक वर्ग के बाहर का उदाहरण दिया गया है :

enums coffeesize{BIG , HUGE , OVERWHELMING }; 
//This semicolon is optional.

इस सम्बन्धी सीमाओं coffeesizeया तो होने के लिए: BIG, HUGE, या OVERWHELMINGएक चर के रूप में।


2

Enum? इसका उपयोग क्यों किया जाना चाहिए? मुझे लगता है कि यह अधिक समझ में आता है जब आप इसका उपयोग करेंगे। मेरा भी यही अनुभव है।

मान लें कि आपके पास डेटाबेस ऑपरेशन बनाना, हटाना, संपादित करना और पढ़ना है।

अब यदि आप एक ऑपरेशन के रूप में एनम बनाते हैं:

public enum operation {
    create("1")
    delete("2")
    edit("3")
    read("4")

    // You may have is methods here
    public boolean isCreate() {
        return this.equals(create);
    }
    // More methods like the above can be written

}

अब, आप कुछ इस तरह की घोषणा कर सकते हैं:

private operation currentOperation;

// And assign the value for it 
currentOperation = operation.create

इसलिए आप इसे कई तरह से इस्तेमाल कर सकते हैं। विशिष्ट चीजों के लिए एनुम का होना हमेशा अच्छा होता है क्योंकि उपरोक्त उदाहरण में डेटाबेस ऑपरेशन को करंट अफेयर्स की जाँच करके नियंत्रित किया जा सकता है । शायद कोई कह सकता है कि यह चर और पूर्णांक मूल्यों के साथ भी पूरा किया जा सकता है। लेकिन मेरा मानना ​​है कि एनम एक सुरक्षित और एक प्रोग्रामर का तरीका है।

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


1

अब तक, मुझे कभी भी एनम का उपयोग करने की आवश्यकता नहीं है। मैं उनके बारे में तब से पढ़ रहा हूं जब उन्हें 1.5 या संस्करण बाघ में पेश किया गया था क्योंकि इसे दिन में वापस बुलाया गया था। उन्होंने वास्तव में मेरे लिए एक 'समस्या' हल नहीं की। जो लोग इसका उपयोग करते हैं (और मैं उनमें से बहुत कुछ देखता हूं), मुझे यकीन है कि यह निश्चित रूप से कुछ उद्देश्य प्रदान करता है । बस मेरी 2 क्वि।


1

यहाँ कई उत्तर हैं, बस दो विशिष्ट बिंदुओं को इंगित करना चाहते हैं:

1) Switch-caseबयान में स्थिरांक के रूप में उपयोग करना । स्विच केस आपको केस के लिए स्ट्रिंग ऑब्जेक्ट्स का उपयोग करने की अनुमति नहीं देगा। दुश्मनी काम आती है। अधिक: http://www.javabeat.net/2009/02/02/how-to-use-enum-in-switch/

2) लागू करना Singleton Design Pattern- एनम फिर से, बचाव के लिए आता है। उपयोग, यहाँ: जावा में एक सिंगलटन के रूप में एनम का उपयोग करने के लिए सबसे अच्छा तरीका क्या है?


1

मुझे अह-हा पल क्या दिया गया था यह एहसास था: कि एनम के पास एक निजी कंस्ट्रक्टर है जो केवल सार्वजनिक गणना के माध्यम से सुलभ है:

enum RGB {
    RED("Red"), GREEN("Green"), BLUE("Blue");

    public static final String PREFIX = "color ";

    public String getRGBString() {
        return PREFIX + color;
    }

    String color;

    RGB(String color) {
        this.color = color;
    }
}

public class HelloWorld {
    public static void main(String[] args) {
        String c = RGB.RED.getRGBString();
        System.out.print("Hello " + c);
    }
}

1

मेरे लिए भविष्य में कोड को पढ़ने योग्य बनाने के लिए गणना का सबसे उपयोगी सहायक मामला अगले स्निपेट में दर्शाया गया है:

public enum Items {
    MESSAGES, CHATS, CITY_ONLINE, FRIENDS, PROFILE, SETTINGS, PEOPLE_SEARCH, CREATE_CHAT
}

@Override
public boolean onCreateOptionsMenu(Menu menuPrm) {
    // Inflate the menu; this adds items to the action bar if it is present.
    getMenuInflater().inflate(R.menu.main, menuPrm);
    View itemChooserLcl;
    for (int i = 0; i < menuPrm.size(); i++) {
        MenuItem itemLcl  = menuPrm.getItem(i);
            itemChooserLcl = itemLcl.getActionView();
            if (itemChooserLcl != null) {
                 //here Im marking each View' tag by enume values:
                itemChooserLcl.setTag(Items.values()[i]);
                itemChooserLcl.setOnClickListener(drawerMenuListener);
            }
        }
    return true;
}
private View.OnClickListener drawerMenuListener=new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        Items tagLcl= (Items) v.getTag();
        switch (tagLcl){
            case MESSAGES: ;
            break;
            case CHATS : ;
            break;
            case CITY_ONLINE : ;
            break;
            case FRIENDS : ;
            break;
            case  PROFILE: ;
            break;
            case  SETTINGS: ;
            break;
            case  PEOPLE_SEARCH: ;
            break;
            case  CREATE_CHAT: ;
            break;
        }
    }
};

1

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

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

एक बेहतर उदाहरण उत्पाद श्रेणी के प्रकार जैसा होगा। मान लीजिए कि आपका सॉफ़्टवेयर डिपार्टमेंट स्टोर के लिए इन्वेंट्री का प्रबंधन करता है। कई उत्पाद श्रेणियां हैं, और कई कारण हैं कि श्रेणियों की यह सूची क्यों बदल सकती है। प्रबंधक एक नई उत्पाद लाइन का स्टॉक करना, अन्य उत्पाद लाइनों से छुटकारा पाना और संभवतः समय-समय पर श्रेणियों को पुनर्गठित करना चाहते हैं। यदि आपको अपने सभी सिस्टम को केवल इसलिए पुनर्निर्माण और पुनर्वितरित करना है क्योंकि उपयोगकर्ता उत्पाद श्रेणी जोड़ना चाहते हैं, तो आपने कुछ ऐसा लिया है जो सरल और तेज़ होना चाहिए (श्रेणी जोड़ना) और इसे बहुत कठिन और धीमा बना दिया।

निचला रेखा, एनम अच्छा है यदि आप जो डेटा का प्रतिनिधित्व कर रहे हैं वह समय के साथ बहुत स्थिर है और सीमित संख्या में निर्भरताएं हैं। लेकिन अगर डेटा बहुत बदल जाता है और बहुत अधिक निर्भरता है, तो आपको कुछ गतिशील की आवश्यकता होती है जिसे संकलन समय (डेटाबेस तालिका की तरह) पर चेक नहीं किया जाता है।


1

एनम आधारित सिंगलटन

एक पुरानी समस्या पर एक आधुनिक नज़र

यह दृष्टिकोण जावा की गारंटी का लाभ उठाकर सिंगलटन को लागू करता है कि किसी भी एनुम मूल्य को केवल एक बार जावा प्रोग्राम में तत्काल लागू किया जाता है और एनम थ्रेड सुरक्षा के लिए निहित समर्थन प्रदान करता है। चूँकि Java enum मान विश्व स्तर पर सुलभ हैं, इसलिए इसे सिंगलटन के रूप में उपयोग किया जा सकता है।

public enum Singleton {
    SINGLETON; 
    public void method() { }
}

यह कैसे काम करता है? खैर, कोड दो की पंक्ति को इस तरह से समझा जा सकता है:

public final static Singleton SINGLETON = new Singleton(); 

और हमें अच्छे पुराने शुरुआती प्रारंभिक सिंग्लटन मिलते हैं।

याद रखें कि चूंकि यह एक एनम है आप हमेशा उदाहरण के माध्यम से उपयोग कर सकते हैं Singleton.INSTANCE:

Singleton s = Singleton.INSTANCE;
लाभ
  • डिसेरिएलाइजेशन के दौरान सिंगलटन के अन्य उदाहरणों को बनाने से रोकने के लिए एनम आधारित सिंगलटन का उपयोग करें क्योंकि एनवीएम द्वारा सीरम के क्रमांकन का ध्यान रखा जाता है। सामान्य जावा वस्तुओं की तुलना में Enum serialization और deserialization अलग तरह से काम करते हैं। केवल एक चीज जो क्रमबद्ध हो जाती है वह है एनम वैल्यू का नाम। डिसेरिएलाइजेशन प्रक्रिया के दौरान एनमvalueOf वांछित उदाहरण प्राप्त करने के लिए डीराइज्ड नाम के साथ विधि का उपयोग किया जाता है।
  • Enum आधारित सिंगलटन प्रतिबिंब के हमले से खुद को बचाने की अनुमति देता है। ईनम प्रकार वास्तव में जावा Enumवर्ग का विस्तार करता है । कारण यह है कि प्रतिबिंब का उपयोग एनम प्रकार की वस्तुओं को त्वरित करने के लिए नहीं किया जा सकता है क्योंकि जावा विनिर्देशन को अस्वीकार करता है और उस नियम को कक्षा की newInstanceविधि के कार्यान्वयन में कोडित Constructorकिया जाता है, जिसका उपयोग आमतौर पर प्रतिबिंब के माध्यम से वस्तुओं को बनाने के लिए किया जाता है:
if ((clazz.getModifiers() & Modifier.ENUM) != 0)
    throw new IllegalArgumentException("Cannot reflectively create enum objects");
  • एनम को क्लोन नहीं किया जाना चाहिए क्योंकि प्रत्येक मूल्य का एक उदाहरण होना चाहिए।
  • सभी सिंगलटन अहसास के बीच सबसे लेकोनिक कोड।
नुकसान
  • एनम आधारित सिंगलटन आलसी आरंभीकरण की अनुमति नहीं देता है।
  • यदि आप अपना डिज़ाइन बदलते हैं और अपने सिंगलटन को मल्टीटन में बदलना चाहते हैं, तो एनम इसकी अनुमति नहीं देगा। मल्टीटन पैटर्न का उपयोग कई उदाहरणों के नियंत्रित निर्माण के लिए किया जाता है, जिसे यह ए के उपयोग के माध्यम से प्रबंधित करता है mapप्रति आवेदन (उदाहरण के लिए java.lang.Runtime) एकल उदाहरण होने के बजाय मल्टीटोन पैटर्न प्रति कुंजी एक उदाहरण सुनिश्चित करता है ।
  • Enum केवल Java 5 में दिखाई देता है इसलिए आप इसे पूर्व संस्करण में उपयोग नहीं कर सकते हैं।

फायदे और नुकसान के साथ हर एक सिंगलटन पैटर्न के कई अहसास हैं।

  • एगर लोडिंग सिंगलटन
  • डबल-चेकिंग लॉकिंग सिंगलटन
  • प्रारंभिक-ऑन-डिमांड धारक मुहावरे
  • एनम आधारित सिंगलटन

उनमें से प्रत्येक का विस्तृत विवरण बहुत अधिक है, इसलिए मैंने सिर्फ एक अच्छे लेख के लिए एक लिंक दिया है - आप सभी सिंगलटन के बारे में जानना चाहते हैं


0

मैं एक उपयोगी मैपिंग इंस्ट्रूमेंट के रूप में एनम का उपयोग करता हूं, if-else बशर्ते कि कई तरीकों को लागू किया जाए।

public enum Mapping {

    ONE("1"),
    TWO("2");

    private String label;

    private Mapping(String label){
        this.label = label;
    }

    public static Mapping by(String label) {

        for(Mapping m: values() {
            if(m.label.equals(label)) return m;
        }

        return null;
    }

}

तो विधि by(String label) आपको एन्यूमरेटेड द्वारा एन्यूमरेटेड मूल्य प्राप्त करने की अनुमति देती है। इसके अलावा, कोई 2 एनम के बीच मैपिंग का आविष्कार कर सकता है। 'एक से एक' डिफ़ॉल्ट संबंध के अलावा '1 से कई' या 'कई से कई' का भी प्रयास कर सकता है

अंत में, enumएक जावा वर्ग है। तो आपके पास mainइसके अंदर विधि हो सकती है, जो कुछ समय में कुछ मैपिंग ऑपरेशन करने की आवश्यकता होने पर उपयोगी हो सकती argsहै।


0

इसके बजाय कास्ट इंट घोषणाओं का एक गुच्छा बनाने के लिए

आप उन सभी को 1 enum में समूहीकृत कर सकते हैं

तो यह सब उनके द्वारा आयोजित आम समूह द्वारा आयोजित किया जाता है


0

एनम वर्ग की तरह हैं। कक्षा की तरह, इसमें भी विधियाँ और विशेषताएँ हैं।

वर्ग के साथ अंतर हैं: 1. एनम स्थिरांक सार्वजनिक, स्थिर, अंतिम हैं। 2. एक एनुम का उपयोग ऑब्जेक्ट बनाने के लिए नहीं किया जा सकता है और यह अन्य वर्गों का विस्तार नहीं कर सकता है। लेकिन यह इंटरफेस को लागू कर सकता है।


0

@BradB उत्तर के अलावा:

यह सच है ... यह अजीब है कि यह एकमात्र उत्तर है जो इसका उल्लेख करता है। जब शुरुआती लोग एनम की खोज करते हैं, तो वे जल्दी से कंपाइलर के लिए वैध पहचानकर्ता की जाँच के लिए एक जादू-टोटके के रूप में लेते हैं। और जब कोड को वितरित सिस्टम पर उपयोग करने का इरादा होता है, तो वे रोते हैं ... कुछ महीने बाद। एनमों के साथ पिछड़ी संगतता बनाए रखें जिसमें मूल्यों की गैर स्थिर सूची है एक वास्तविक चिंता है, और दर्द। ऐसा इसलिए है क्योंकि जब आप किसी मौजूदा एनुम का मान जोड़ते हैं, तो इसका प्रकार बदल जाता है (नाम के बावजूद नहीं)।

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

निष्कर्ष में: जब आप चाहें, इसका उपयोग करें, लेकिन, कृपया जांच लें कि उपयोग किया गया डेटा डोमेन एक परिमित है, पहले से ही ज्ञात, निश्चित सेट

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.