जावा स्विच स्टेटमेंट

जावा स्विच के बारे में कुछ सिद्धांत

कल्पना कीजिए कि आप सड़क के एक कांटे पर रुके हुए शूरवीर हैं। यदि आप बाएं जाते हैं, तो आप अपना घोड़ा खो देंगे। सही चलेंगे तो ज्ञान मिलेगा। हम कोड में इस स्थिति का प्रतिनिधित्व कैसे करेंगे? आप शायद पहले से ही जानते हैं कि हम ये निर्णय लेने के लिए if-then और if-then-else जैसे निर्माणों का उपयोग करते हैं।

if (turn_left) { 
    System.out.println("You will lose your horse"); 
}
if (turn_right) {
    System.out.println("You will gain knowledge");
}
else 
    System.out.println("So you're just going to stand there?");

लेकिन क्या होगा अगर सड़क दो में नहीं, बल्कि दस में विभाजित हो जाए? आपके पास ऐसी सड़कें हैं जो "पूरी तरह से दाईं ओर", "थोड़ी सी बाईं ओर", "थोड़ी सी और बाईं ओर" और इसी तरह कुल 10 संभावित सड़कें हैं? कल्पना करें कि इस संस्करण में आपका "if-then-else " कोड कैसे बढ़ेगा!

if (option1)
{…}
else if (option2)
{…}
…
else if (optionN) ...

मान लीजिए कि आपके पास सड़क में 10-तरफ़ा कांटा है (यह यहाँ महत्वपूर्ण है कि विकल्पों की संख्या परिमित है)। ऐसी स्थितियों के लिए, जावा में स्विच स्टेटमेंट होता है।

       switch (ExpressionForMakingAChoice) {
           case (Value1):
               Code1;
               break;
           case (Value2):
               Code2;
               break;
...
           case (ValueN):
               CodeN;
               break;
           default:
               CodeForDefaultChoice;
               break;
       }

इस प्रकार कथन काम करता है:

• ExpressionForMakingAChoice का मूल्यांकन किया जाता है। फिर स्विच स्टेटमेंट परिणामी मूल्य की तुलना अगले ValueX (जिस क्रम में वे सूचीबद्ध हैं) के साथ करते हैं।
• यदि ExpressionForMakingAchoice ValueX से मेल खाता है, तो कोलन के बाद वाला कोड निष्पादित होता है।
• यदि एक ब्रेक स्टेटमेंट का सामना करना पड़ता है, तो नियंत्रण स्विच स्टेटमेंट के बाहर स्थानांतरित हो जाता है।
• यदि ExpressionForMakingAchoice किसी ValueX से मेल नहीं खाता है, तो नियंत्रण CodeForDefaultCase को पास करता है।

महत्वपूर्ण बिंदु

• स्विच स्टेटमेंट में, ExpressionForMakingAChoice का प्रकार निम्न में से एक होना चाहिए:

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

आइए अब एक नजर डालते हैं कि जावा में स्विच स्टेटमेंट का उपयोग कैसे किया जाता है

आप चिंता न करें: हमने सिद्धांत को पूरा कर लिया है। निम्नलिखित उदाहरण देखने के बाद, सब कुछ बहुत स्पष्ट हो जाएगा। खैर, चलिए शुरू करते हैं। आइए हमारे सौर मंडल के ग्रहों से जुड़े खगोल विज्ञान के एक उदाहरण को देखें। नवीनतम अंतर्राष्ट्रीय दृष्टिकोणों के अनुसार, हमने प्लूटो को बाहर कर दिया है (इसकी कक्षा के गुणों के कारण)। हमें याद है कि हमारे ग्रह सूर्य से उनकी दूरी के अनुसार इस प्रकार व्यवस्थित हैं: बुध, शुक्र, पृथ्वी, मंगल, बृहस्पति, शनि, यूरेनस और नेपच्यून। चलिए एक Java मेथड लिखते हैं जो किसी ग्रह की क्रमसूचक संख्या (सूर्य से उसकी दूरी के सापेक्ष) लेता है और ग्रह के वायुमंडल के मुख्य घटकों को सूची <स्ट्रिंग> के रूप में लौटाता है।. आपको याद होगा कि कुछ ग्रहों की वायुमंडलीय संरचना समान होती है। इस प्रकार, शुक्र और मंगल में मुख्य रूप से कार्बन डाइऑक्साइड होता है; बृहस्पति और शनि के वातावरण में हाइड्रोजन और हीलियम शामिल हैं; और यूरेनस और नेप्च्यून गैसों की अंतिम जोड़ी में मीथेन जोड़ते हैं। यहाँ हमारा कार्य है:

public static List<String> getPlanetAtmosphere(int seqNumberFromSun) {
    List<String> result = new ArrayList<>();
    switch (seqNumberFromSun) {
        case 1: result.add("No atmosphere");
            break;
        case 2:
        case 4: result.add("Carbon dioxide");
            break;
        case 3: result.add("Carbon dioxide");
            result.add("Nitrogen");
            result.add ("Oxygen");
            break;
        case 5:
        case 6: result.add("Hydrogen");
            result.add("Helium");
            break;
        case 7:
        case 8: result.add("Methane");
            result.add("Hydrogen");
            result.add("Helium");
            break;
        default:
            break;
    }
    return result;
}

ध्यान दें कि हम समान वायुमंडलीय संघटन वाले ग्रहों के लिए समान कोड का उपयोग कर रहे हैं। हमने लगातार केस स्टेटमेंट्स का उपयोग करके ऐसा किया। यदि हम अपने गृह ग्रह के वातावरण की संरचना प्राप्त करना चाहते हैं, तो हम तर्क के रूप में 3 के साथ अपनी विधि कहते हैं:

getPlanetAtmosphere(3).
System.out.println(getPlanetAtmosphere(3)) returns ["Carbon dioxide", "Nitrogen", "Oxygen"].

ब्रेक के साथ प्रयोग: अगर हम सभी ब्रेक स्टेटमेंट हटा दें तो क्या होगा? आइए इसे एक बार आज़माकर देखते हैं:

    public static List<String> getPlanetAtmosphere(int seqNumberFromSun) {
        List<String> result = new ArrayList<>();
        switch (seqNumberFromSun) {
            case 1: result.add("No atmosphere");
            case 2:
            case 4: result.add("Carbon dioxide");
            case 3: result.add("Carbon dioxide");
                result.add("Nitrogen");
                result.add ("Oxygen");
            case 5:
            case 6: result.add("Hydrogen");
                result.add("Helium");
            case 7:
            case 8: result.add("Methane");
                result.add("Hydrogen");
                result.add("Helium");
            default:
        }
        return result;
    }

यदि हम System.out.println(getPlanetAtmosphere(3)) का परिणाम प्रिंट करते हैं , तो हम पाते हैं कि हमारा ग्रह इतना रहने योग्य नहीं है। या यह है? खुद के लिए न्यायाधीश: ["कार्बन डाइऑक्साइड", "नाइट्रोजन", "ऑक्सीजन", "हाइड्रोजन", "हीलियम", "मीथेन", "हाइड्रोजन", "हीलियम"] । ऐसा क्यों हुआ? प्रोग्राम स्विच ब्लॉक के अंत तक पहले मैच के बाद सभी केस स्टेटमेंट्स को निष्पादित करता है।

ब्रेक स्टेटमेंट का अत्यधिक अनुकूलन

ध्यान दें कि हम ब्रेक स्टेटमेंट और केस को अलग-अलग तरीके से व्यवस्थित करके विधि में सुधार कर सकते हैं ।

public static List<String> getPlanetAtmosphere(int seqNumberFromSun) {
    List<String> result = new ArrayList<>();
    switch (seqNumberFromSun) {
        case 1: result.add("No atmosphere");
                break;
        case 3: result.add("Nitrogen");
                result.add ("Oxygen");
        case 2:
        case 4: result.add("Carbon dioxide");
                break;
        case 7:
        case 8: result.add("Methane");
        case 5:
        case 6: result.add("Hydrogen");
                result.add("Helium");
    }
     return result;
}

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

अगर से मतभेद

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

निष्कर्ष

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