जावा में सशर्त निर्माण (Conditional constructs in Java)

ए. यदि निर्माण के चार प्रकार:

1. सरल if (एकल-वैकल्पिक): एक कोड ब्लॉक को केवल तभी निष्पादित करता है जब निर्दिष्ट बूलियन स्थिति true का मूल्यांकन करती है।

   if (शेष < 1000) {
       System.out.println('कम शेष चेतावनी!');
   }

2. दोहरा-वैकल्पिक if-else: यदि स्थिति true है तो if ब्लॉक निष्पादित करता है; अन्यथा else ब्लॉक निष्पादित करता है।

   if (संख्या % 2 == 0) {
       System.out.println('सम संख्या');
   }अन्यथा{
       System.out.println('विषम संख्या');
   }

3. The if-else-if सीढ़ी (बहु-वैकल्पिक चयन): ऊपर से नीचे तक क्रमिक रूप से स्थितियों का मूल्यांकन करता है। जैसे ही कोई शर्त पूरी हो जाती है, उसका ब्लॉक निष्पादित हो जाता है, और सीढ़ी का शेष भाग छोड़ दिया जाता है। यदि कोई शर्त मेल नहीं खाती है, तो पिछला else फ़ॉलबैक के रूप में निष्पादित होता है।

   if (अंक >=90)
       ग्रेड = 'ए';
   अन्यथा यदि (अंक>=80)
       ग्रेड = 'बी';
   अन्यथा यदि (अंक>=70)
       ग्रेड = 'सी';
   अन्यथा
       ग्रेड = 'डी';

4. नेस्टेड if: एक if या if-else स्टेटमेंट दूसरे if या else ब्लॉक के मुख्य भाग के अंदर रखा जाता है, जिसका उपयोग बहु-स्तरीय मानदंडों के लिए किया जाता है सत्यापन.

ए. स्विच-केस का औपचारिक सिंटैक्स:

स्विच (स्विच_एक्सप्रेशन) {
    केस स्थिरांक1:
        // यदि स्विच_एक्सप्रेशन == स्थिरांक 1 है तो कथन निष्पादित किया गया है
        टूटना; // तुरंत स्विच ब्लॉक से बाहर निकलें
    केस स्थिरांक2:
        // यदि स्विच_एक्सप्रेशन == स्थिरांक 2 है तो कथन निष्पादित किया गया है
        टूटना;
    डिफ़ॉल्ट:
        // यदि कोई केस स्थिरांक मेल नहीं खाता है तो स्टेटमेंट निष्पादित किया जाता है
        टूटना;
}

बी. जावा में स्विच-केस के लिए कठोर नियम:

• अनुमत डेटा प्रकार: स्विच एक्सप्रेशन का मूल्यांकन इस प्रकार होना चाहिए: byte, short, char, int, String (जावा) 7+), या enum।
  सख्ती से वर्जित: फ्लोट, डबल, और बूलियन का उपयोग स्विच अभिव्यक्ति में नहीं किया जा सकता है!
• केस लेबल स्थिर होना चाहिए: प्रत्येक केस लेबल एक अपरिवर्तनीय शाब्दिक या अंतिम संकलन-समय स्थिर अभिव्यक्ति होना चाहिए। वेरिएबल (जैसे, केस x:) या रेंज (जैसे, केस 80 से 90:) पूरी तरह से अवैध हैं।
• अद्वितीय केस लेबल: एक ही स्विच निर्माण में डुप्लिकेट केस लेबल एक संकलन-समय त्रुटि उत्पन्न करते हैं।
• वैकल्पिक डिफ़ॉल्ट: डिफॉल्ट लेबल वैकल्पिक है और इसे स्विच के अंदर कहीं भी रखा जा सकता है, हालांकि यह पारंपरिक रूप से सबसे अंत में स्थित है।

ए. फॉल-थ्रू क्या है?

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

बी. ट्रेसिंग फ़ॉल-थ्रू (क्लासिक बोर्ड समस्या):

int विकल्प = 2;
स्विच (विकल्प) {
    केस 1:
        System.out.print('अल्फा');
    केस 2:
        System.out.print("बीटा"); // मिलान! निष्पादित करता है. (कोई ब्रेक नहीं!)
    केस 3:
        System.out.print("गामा"); // गिर जाता है! निष्पादित करता है.
        तोड़ना; // यहाँ टूट जाता है!
    केस 4:
        System.out.print("डेल्टा");
    डिफ़ॉल्ट:
        System.out.print('ओमेगा');
}

आउटपुट: बीटा गामा

स्पष्टीकरण: चूंकि केस 2 मेल खाता है और इसमें ब्रेक का अभाव है, निष्पादन केस 3 में गिर जाता है, "गामा" प्रिंट करता है, जहां यह अंततः ब्रेक स्टेटमेंट को हिट करता है और निकास.

मेनू-संचालित क्षेत्र कैलकुलेटर:

आयात java.util.Scanner;

सार्वजनिक वर्ग एरियामेनूडेमो {
    सार्वजनिक स्थैतिक शून्य मुख्य(स्ट्रिंग[] तर्क) {
        स्कैनर इन = नया स्कैनर (System.in);
        System.out.println('====== ज्यामितीय क्षेत्र कैलकुलेटर ======');
        System.out.println(''1. वृत्त का क्षेत्रफल');
        System.out.println("2. आयत का क्षेत्रफल");
        System.out.println("3. त्रिभुज का क्षेत्रफल");
        System.out.print('अपनी पसंद दर्ज करें (1-3):');
        int पसंद = in.nextInt();

        स्विच (विकल्प) {
            केस 1:
                System.out.print ("त्रिज्या दर्ज करें:");
                डबल आर = in.nextDouble();
                दोहरा वृत्तक्षेत्र = गणित.पीआई * आर * आर;
                System.out.println(''वृत्त का क्षेत्रफल='' +वृत्तक्षेत्र);
                तोड़ना;

            केस 2:
                System.out.print ("लंबाई और चौड़ाई दर्ज करें:");
                डबल एल = in.nextDouble();
                डबल बी = in.nextDouble();
                डबल रेक्टएरिया = एल * बी;
                System.out.println("आयत का क्षेत्रफल = " + आयतक्षेत्र);
                तोड़ना;

            केस 3:
                System.out.print('आधार और ऊंचाई दर्ज करें:');
                डबल बेस = in.nextDouble();
                दोगुनी ऊँचाई = in.nextDouble();
                दोहरा त्रिक्षेत्र = 0.5 * आधार * ऊँचाई;
                System.out.println("त्रिकोण का क्षेत्रफल = "+त्रिक्षेत्र);
                तोड़ना;

            डिफ़ॉल्ट:
                System.out.println ("त्रुटि: अमान्य विकल्प! कृपया 1 और 3 के बीच चयन करें");
                तोड़ना;
        }
    }
}

इंटरएक्टिव बैंकिंग सिम्युलेटर:

आयात java.util.Scanner;

पब्लिक क्लास एटीएमसिम्युलेटर {
    सार्वजनिक स्थैतिक शून्य मुख्य(स्ट्रिंग[] तर्क) {
        स्कैनर इन = नया स्कैनर (System.in);
        दोहरा शेष = 50000.0;

        System.out.println('====== नेशनल बैंक एटीएम में आपका स्वागत है ======');
        System.out.println(''1. शेष राशि जांचें');
        System.out.println(''2. जमा निधि');
        System.out.println(''3. नकद निकालें');
        System.out.println('4. बाहर निकलें');
        System.out.print('एक विकल्प चुनें (1-4):');
        int विकल्प = in.nextInt();

        स्विच (विकल्प) {
            केस 1:
                System.out.println ("आपका उपलब्ध शेष है: ₹" + शेष);
                तोड़ना;
            केस 2:
                System.out.print ("जमा राशि दर्ज करें: ₹");
                दोहरा जमा = in.nextDouble();
                यदि (जमा > 0) {
                    शेष += जमा;
                    System.out.println ("जमा सफल! नया शेष: ₹" + शेष);
                }अन्यथा{
                    System.out.println('अमान्य राशि!');
                }
                तोड़ना;
            केस 3:
                System.out.print ("निकासी राशि दर्ज करें: ₹");
                डबल निकासी = in.nextDouble();
                यदि (निकासी > 0 && निकासी <= शेष) {
                    शेष - = निकालना;
                    System.out.println('निकासी सफल! शेष शेष: ₹' + शेष);
                }अन्यथा{
                    System.out.println('लेन-देन विफल: अपर्याप्त धनराशि या अमान्य राशि!');
                }
                तोड़ना;
            केस 4:
                System.out.println ("हमारे साथ बैंकिंग करने के लिए धन्यवाद। आपका दिन मंगलमय हो!");
                तोड़ना;
            डिफ़ॉल्ट:
                System.out.println('अमान्य चयन! कृपया 1 और 4 के बीच एक विकल्प चुनें');
                तोड़ना;
        }
    }
}

प्रगतिशील स्लैब टैक्स कैलकुलेटर:

आयात java.util.Scanner;

पब्लिक क्लास इनकमटैक्सकैलकुलेटर {
    सार्वजनिक स्थैतिक शून्य मुख्य(स्ट्रिंग[] तर्क) {
        स्कैनर इन = नया स्कैनर (System.in);
        System.out.print ("वार्षिक कर योग्य आय दर्ज करें: ₹");
        दोगुनी आय = in.nextDouble();
        दोहरा कर = 0.0;

        // प्रगतिशील टैक्स स्लैब:
        // ₹2,50,000 तक : शून्य (0%)
        // ₹2,50,001 से ₹5,00,000: ₹2,50,000 से अधिक आय का 5%
        // ₹5,00,001 से ₹10,00,000 : ₹12,500 + ₹5,00,000 से अधिक आय का 20%
        // ₹10,00,000 से ऊपर: ₹1,12,500 + ₹10,00,000 से अधिक आय का 30%
        यदि (आय <= 250000) {
            कर = 0.0;
        } अन्यथा यदि (आय <= 500000) {
            कर = (आय - 2500000) * 0.05;
        } अन्यथा यदि (आय <= 1000000) {
            कर = 12500 + (आय - 500000) * 0.20;
        }अन्यथा{
            कर = 112500 + (आय - 1000000) * 0.30;
        }

        दोहरा उपकर = कर * 0.04; // 4% स्वास्थ्य और शिक्षा उपकर
        दोगुना कुल कर = कर + उपकर;

        System.out.println('देय आयकर: ₹' + कर);
        System.out.println('शिक्षा उपकर (4%) : ₹' + उपकर);
        System.out.println('कुल कर देयता: ₹' + कुलकर);
    }
}

ए. ग्रेगोरियन लीप वर्ष नियम:

एक वर्ष एक लीप वर्ष है यदि:

1. यह 4 से विभाज्य है, AND
2. यह 100 से विभाज्य नहीं है, जब तक कि
3. यह 400 (शताब्दी लीप वर्ष जैसे 1600, 2000, 2400) से भी विभाज्य है।

आयात java.util.स्कैनर;

पब्लिक क्लास लीपइयरचेक {
    सार्वजनिक स्थैतिक शून्य मुख्य(स्ट्रिंग[] तर्क) {
        स्कैनर इन = नया स्कैनर (System.in);
        System.out.print('एक वर्ष दर्ज करें (जैसे 2024):');
        int वर्ष = in.nextInt();

        बूलियन इसलीप = गलत;
        यदि ((वर्ष % 4 == 0 && वर्ष % 100 != 0) || (वर्ष % 400 == 0)) {
            इसलीप = सत्य;
        }

        अगर (लीप है) {
            System.out.println(वर्ष + "एक लीप वर्ष है (366 दिन)।");
        }अन्यथा{
            System.out.println(वर्ष + "एक सामान्य वर्ष है (365 दिन)।");
        }
    }
}

ए. स्विच-केस में स्ट्रिंग मिलान (जावा 7+):

जावा 7 से शुरू करके, प्रोग्रामर String ऑब्जेक्ट का उपयोग सीधे स्विच एक्सप्रेशन में कर सकते हैं। स्ट्रिंग तुलना केस-संवेदी है और आंतरिक रूप से String.equals():

स्ट्रिंग दिवस = "सोमवार";
स्विच (day.toLowerCase()) {
    मामला "सोमवार":
    मामला "मंगलवार":
    मामला "बुधवार":
    मामला "गुरुवार":
    मामला "शुक्रवार":
        System.out.println('सप्ताह का दिन (स्कूल/कार्य)');
        तोड़ना;
    मामला "शनिवार":
    मामला "रविवार":
        System.out.println('सप्ताहांत (छुट्टी)');
        तोड़ना;
    डिफ़ॉल्ट:
        System.out.println('अमान्य दिन का नाम!');
        तोड़ना;
}

ए. प्रोग्रेसिव लेट रिटर्न फाइन स्ट्रक्चर:

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

• पहले 5 दिन देर से: ₹0.50 प्रति दिन
• अगले 5 दिन (6-10 दिन): ₹1.00 प्रति दिन
• 10 दिन से ऊपर: ₹2.00 प्रति दिन

डबल जुर्माना = 0.0;
यदि (दिन <= 5) {
    ठीक = दिन * 0.50;
} अन्यथा यदि (दिन <= 10) {
    जुर्माना = (5 * 0.50) + (दिन - 5) * 1.00;
}अन्यथा{
    जुर्माना = (5 * 0.50) + (5 * 1.00) + (दिन - 10) * 2.00;
}
System.out.println('कुल लाइब्रेरी जुर्माना: ₹' + जुर्माना);

निष्पादन दक्षता को अधिकतम करने के लिए हमेशा सबसे अधिक मिलान वाली स्थिति को यदि-और-यदि सीढ़ी के शीर्ष पर रखें। स्विच-केस निर्माणों में, समूह केस लेबल जो समान तर्क को एक साथ साझा करते हैं (उदाहरण के लिए, केस 'ए': केस 'ई': केस 'आई': केस 'ओ': केस 'यू': प्रिंट("स्वर"); ब्रेक;) अनावश्यक कोड दोहराव से बचने के लिए।