अभिव्यक्ती बदला

पुनरावृत्ती ही शिकण्याची जननी आहे. जरी आपण आधी Java च्या switch keyword बद्दल बोललो असलो तरी आज आपण मूलभूत गोष्टींचे पुनरावलोकन करू आणि काही नवीन माहिती शोधू.

Java मध्ये दोन प्रकारचे स्विच कंस्ट्रक्ट आहेत: स्विच स्टेटमेंट आणि स्विच एक्सप्रेशन. स्विच एक्सप्रेशन जावा 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;
}

स्विच स्टेटमेंट हा एकामागून एक कार्यान्वित केल्या जाणार्‍या रचनांचा संच आहे. हे तुम्हाला मूल्य परत करू देत नाही. स्विच स्टेटमेंट वापरताना मुख्य समस्या ही आहे की तुम्ही केस एक्सप्रेशन्सची अनंत संख्या जोडू शकता आणि प्रोग्रामरद्वारे या क्षमतेचा अनेकदा गैरवापर केला जातो.

Java 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;
}

Java 13 मध्ये, स्विच अभिव्यक्ती अजूनही एक प्रायोगिक वैशिष्ट्य होती. ते उपलब्ध करून देण्यासाठी, Java 12 प्रमाणेच, संकलित आणि चालवताना तुम्हाला --enable-preview कमांड वापरण्याची आवश्यकता आहे. Java 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();
}

काहीशा कुरूप जुन्या मार्गाऐवजी, जिथे तुम्हाला फक्त instanceof वापरून व्हेरिएबल तपासावे लागले नाही तर ते एका विशिष्ट प्रकारात कास्ट करावे लागेल.

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

हे बदल Amber प्रकल्पाचा भाग आहेत, ज्याचा उद्देश Java मध्ये पॅटर्न जुळणारे समर्थन जोडणे आहे.

आवृत्ती 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();
    };
}

सर्वसाधारणपणे, प्रत्येक नवीन आवृत्ती भाषेमध्ये अधिकाधिक मनोरंजक वैशिष्ट्ये आणते, ज्यामुळे Java विकास आणखी थंड होतो.