వ్యక్తీకరణను మార్చండి

పునరావృతం నేర్చుకునే తల్లి. మేము ఇంతకు ముందు జావా స్విచ్ కీవర్డ్ గురించి మాట్లాడినప్పటికీ, ఈ రోజు మేము ప్రాథమికాలను సమీక్షిస్తాము మరియు కొంత కొత్త సమాచారాన్ని పరిశీలిస్తాము.

జావాలో రెండు రకాల స్విచ్ నిర్మాణాలు ఉన్నాయి: స్విచ్ స్టేట్‌మెంట్ మరియు స్విచ్ ఎక్స్‌ప్రెషన్. స్విచ్ ఎక్స్‌ప్రెషన్ జావా 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 ఒక ప్రయోగాత్మక ఫీచర్‌ను జోడించింది: స్విచ్ యొక్క కొత్త వెర్షన్ — స్విచ్ స్టేట్‌మెంట్ కాదు, స్విచ్ ఎక్స్‌ప్రెషన్ — ఇది విలువను అందించగలదు, ఫంక్షనల్ ప్రోగ్రామింగ్‌ను అంతర్గతంగా ఉపయోగించగలదు మరియు సాధారణ విలువ కలిగిన కేస్ స్టేట్‌మెంట్‌లను విలీనం చేస్తుంది, తద్వారా కాంపాక్ట్ నిర్మించండి.

జావా 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;
}

దిగుబడి మరియు విరామం మధ్య ప్రధాన వ్యత్యాసం ఏమిటంటే, బ్రేక్ రిటర్న్స్ ఎగ్జిక్యూషన్ కంట్రోల్‌ని కేస్ స్టేట్‌మెంట్ నుండి అందిస్తుంది, అయితే ఈల్డ్ మొత్తం స్విచ్ యొక్క ఫలితాన్ని అందిస్తుంది , ఇది అంతర్గత రిటర్న్ స్టేట్‌మెంట్ వలె పనిచేస్తుంది.

Java 14లో, ఆపరేటర్ యొక్క ఉదాహరణ మార్చబడింది మరియు ఇప్పుడు ఇలా ఉపయోగించవచ్చు:

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

మీరు వేరియబుల్‌ని ఇన్‌స్టాన్స్‌ని ఉపయోగించి తనిఖీ చేయడమే కాకుండా , దానిని నిర్దిష్ట రకానికి ప్రసారం చేయాల్సిన కొంత అగ్లీ పాత మార్గానికి బదులుగా .

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();
    };
}

సాధారణంగా, ప్రతి కొత్త వెర్షన్ భాషలోకి మరిన్ని ఆసక్తికరమైన ఫీచర్లను తెస్తుంది, ఇది జావా డెవలప్‌మెంట్‌ను మరింత చల్లగా చేస్తుంది.