स्विच अभिव्यक्ति

दोहराव सीखने की जननी है। हालाँकि हम पहले ही जावा के स्विच कीवर्ड के बारे में बात कर चुके हैं, आज हम मूलभूत बातों की समीक्षा करेंगे और कुछ नई जानकारी प्राप्त करेंगे।

जावा में दो प्रकार के स्विच कंस्ट्रक्शन होते हैं: स्विच स्टेटमेंट और स्विच एक्सप्रेशन। जावा 14 में स्विच एक्सप्रेशन आधिकारिक हो गया, जो संस्करण 12 और 13 में दो अनौपचारिक "पूर्वावलोकन" वेरिएंट में मौजूद था।

लेकिन चलिए शुरू से शुरू करते हैं। आइए याद करें कि संस्करण 12 से पहले एक अच्छा पुराना स्विच कैसा दिखता था:

public String getProductTypeByName(String product) {
    String productType = "";

    switch (product) {
        case "Apple":
            productType = "Fruit";
            break;

        case "Peach":
            productType = "Fruit";
            break;

        case "Raspberry":
            productType = "Berry";
            break;

        case "Cherry":
            productType = "Berry";
            break;

        case "Tomato":
            productType = "Vegetable";
            break;

        default:
            productType = "other";
            break;
    }
        
    return productType;
}

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

जावा 12 में एक प्रयोगात्मक विशेषता को जोड़ा गया: स्विच का एक नया संस्करण - एक स्विच स्टेटमेंट नहीं, बल्कि एक स्विच एक्सप्रेशन - जो एक मूल्य उत्पन्न कर सकता है, आंतरिक रूप से कार्यात्मक प्रोग्रामिंग का उपयोग कर सकता है, और केस स्टेटमेंट को मर्ज कर सकता है जिसका एक सामान्य मूल्य है, जिससे कॉम्पैक्ट का निर्माण करें।

Java 12 में, आप getProductTypeByName() विधि को निम्नानुसार फिर से लिख सकते हैं:

public String getProductTypeByName(String product) {
    return switch (product) {
        case "Apple", "Peach" -> "Fruit";
        case "Raspberry", "Cherry" -> "Berry";
        case "Tomato" -> "Vegetable";
        default -> "other";

    };
}

अब कोड साफ दिखता है। कार्यात्मक प्रोग्रामिंग से तीर सिंटैक्स हमें ब्रेक कीवर्ड के बिना मान वापस करने देता है, और सामान्य तौर पर, स्विच को निष्पादित करने का परिणाम अब एक चर में सहेजा जा सकता है या रिटर्न कीवर्ड के माध्यम से लौटाया जा सकता है।

यदि हमें न केवल एक परिणाम वापस करने की आवश्यकता है, बल्कि कोड की कई पंक्तियाँ भी हैं, तो हमारा स्विच इस तरह दिखेगा:

public String getProductTypeByName(String product) {
    var result = switch (product) {
        case "Apple", "Peach" -> {
            System.out.println("This is a Fruit");
            break "Fruit";
        }
        case "Raspberry", "Cherry" -> {
            System.out.println("This is a Berry");
            break "Berry";
        }
        case "Tomato" -> {
            System.out.println("This is a Vegetable");
            break "Vegetable";
        }
        default -> {
            break "other";
        }

    };
     return result;
}

जावा 13 में, स्विच एक्सप्रेशन अभी भी एक प्रायोगिक विशेषता थी। इसे उपलब्ध कराने के लिए, ठीक जावा 12 की तरह, आपको कंपाइल और रन करते समय --enable-preview कमांड का उपयोग करने की आवश्यकता है। जावा 13 में स्विच का मुख्य और अनिवार्य रूप से केवल "नवाचार" उपज कीवर्ड है, जिसने ब्रेक को बदल दिया ।

public String getProductTypeByName(String product) {
    var result = switch (product) {
        case "Apple", "Peach" -> {
            System.out.println("This is a Fruit");
            yield "Fruit";
        }
        case "Raspberry", "Cherry" -> {
            System.out.println("This is a Berry");
            yield "Berry";
        }
        case "Tomato" -> {
            System.out.println("This is a Vegetable");
            yield "Vegetables";
        }
        default -> {
            System.out.println("Other");
            yield "other";
        }

    };
    return result;
}

उपज और ब्रेक के बीच मुख्य अंतर यह है कि ब्रेक केस स्टेटमेंट से निष्पादन नियंत्रण लौटाता है , लेकिन उपज पूरे स्विच का परिणाम देता है , आंतरिक रिटर्न स्टेटमेंट की तरह काम करता है।

जावा 14 में, उदाहरण ऑपरेटर बदल गया है और अब इसे इस तरह इस्तेमाल किया जा सकता है:

if (o instanceof String s) {
s.toLowerCase();
}

कुछ बदसूरत पुराने तरीके के बजाय जहां आपको न केवल instof का उपयोग करके चर की जांच करनी थी , बल्कि इसे एक विशिष्ट प्रकार में डालना था।

if(s instanceof String) {
((String) s).toLowerCase();
}

ये परिवर्तन एम्बर प्रोजेक्ट का हिस्सा हैं, जिसका उद्देश्य जावा में पैटर्न मिलान समर्थन जोड़ना है।

संस्करण 14 में उदाहरण ऑपरेटर में परिवर्तन और संस्करण 16 में विस्तार के लिए धन्यवाद, पैटर्न मिलान ने इसे संस्करण 17 में बना दिया। सच है, यह अभी के लिए केवल एक पूर्वावलोकन के रूप में मौजूद है। आप इसे --enable-preview के साथ आज़मा सकते हैं :

public String getObjectType(Object object) {
    return switch (object) {
        case Integer i -> "Integer";
        case Long l -> "Long";
        case String s -> "String";
        default -> object.toString();
    };
}

सामान्य तौर पर, प्रत्येक नया संस्करण भाषा में अधिक से अधिक दिलचस्प सुविधाएँ लाता है, जो जावा के विकास को और भी बेहतर बनाता है।