జావా స్విచ్ స్టేట్‌మెంట్

జావా స్విచ్ గురించి కొంచెం సిద్ధాంతం

మీరు రోడ్డులోని చీలిక వద్ద ఆగి ఉన్న గుర్రం అని ఊహించుకోండి. మీరు ఎడమవైపు వెళితే, మీరు మీ గుర్రాన్ని కోల్పోతారు. మీరు సరిగ్గా వెళితే, మీరు జ్ఞానం పొందుతారు. మేము ఈ పరిస్థితిని కోడ్‌లో ఎలా సూచిస్తాము? ఈ నిర్ణయాలు తీసుకోవడానికి మేము 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 (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తో సరిపోలకపోతే, ఏ చర్య అమలు చేయబడదు.
• విరామ ప్రకటన అవసరం లేదు . అది లేనట్లయితే, కోడ్ మొదటి బ్రేక్ సంభవించే వరకు లేదా స్విచ్ స్టేట్‌మెంట్ ముగిసే వరకు (కేస్ స్టేట్‌మెంట్‌లలో తదుపరి పోలికలను విస్మరిస్తూ) అమలు చేయబడుతూ ఉంటుంది .
• అనేక ఎంపికల కోసం ఒకే కోడ్‌ని అమలు చేయాల్సి ఉంటే, మేము అనేక వరుస కేస్ స్టేట్‌మెంట్‌లను పేర్కొనడం ద్వారా నకిలీని తొలగించవచ్చు.

జావాలో స్విచ్ స్టేట్‌మెంట్ ఎలా ఉపయోగించబడుతుందో ఇప్పుడు చూద్దాం

మీరు చింతించకండి: మేము సిద్ధాంతంతో పూర్తి చేసాము. మీరు ఈ క్రింది ఉదాహరణలను చూసిన తర్వాత, ప్రతిదీ చాలా స్పష్టంగా కనిపిస్తుంది. సరే, ప్రారంభిద్దాం. మన సౌర వ్యవస్థలోని గ్రహాలకు సంబంధించిన ఖగోళ శాస్త్రం నుండి ఒక ఉదాహరణ చూద్దాం. తాజా అంతర్జాతీయ వైఖరికి అనుగుణంగా, మేము ప్లూటోను మినహాయించాము (దాని కక్ష్య యొక్క లక్షణాల కారణంగా). మన గ్రహాలు సూర్యుడి నుండి దూరం ద్వారా ఈ క్రింది విధంగా అమర్చబడి ఉన్నాయని మేము గుర్తుచేసుకుంటాము: బుధుడు, శుక్రుడు, భూమి, మార్స్, బృహస్పతి, శని, యురేనస్ మరియు నెప్ట్యూన్. గ్రహం యొక్క ఆర్డినల్ సంఖ్యను (సూర్యుని నుండి దాని దూరానికి సంబంధించి) తీసుకొని, గ్రహం యొక్క వాతావరణంలోని ప్రధాన భాగాలను జాబితా<String> గా తిరిగి ఇచ్చే జావా పద్ధతిని వ్రాద్దాం.. కొన్ని గ్రహాలు ఒకే విధమైన వాతావరణ కూర్పును కలిగి ఉన్నాయని మీరు గుర్తుంచుకుంటారు. అందువలన, వీనస్ మరియు మార్స్ ప్రధానంగా కార్బన్ డయాక్సైడ్ కలిగి ఉంటాయి; బృహస్పతి మరియు శని వాతావరణం హైడ్రోజన్ మరియు హీలియం కలిగి ఉంటుంది; మరియు యురేనస్ మరియు నెప్ట్యూన్ చివరి జత వాయువులకు మీథేన్‌ను జోడిస్తాయి. ఇక్కడ మా ఫంక్షన్ ఉంది:

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 స్టేట్‌మెంట్ ఏదైనా బూలియన్ వ్యక్తీకరణను కలిగి ఉంటుందని మర్చిపోవద్దు . మీ కోడ్‌ని డిజైన్ చేసేటప్పుడు దీన్ని గుర్తుంచుకోండి.

ముగింపు

• if స్టేట్‌మెంట్‌లతో మీ కోడ్‌ను అస్తవ్యస్తం చేయకుండా ఉండటానికి రెండు కంటే ఎక్కువ శాఖల కోసం కేస్ స్టేట్‌మెంట్‌ను ఉపయోగించండి .
• బ్రేక్ స్టేట్‌మెంట్‌ను చొప్పించడం ద్వారా ప్రతి నిర్దిష్ట విలువ (కేస్ స్టేట్‌మెంట్) కోసం బ్రాంచ్ యొక్క లాజికల్ బ్లాక్‌ను పూర్తి చేయడం మర్చిపోవద్దు .
• స్విచ్ స్టేట్‌మెంట్ యొక్క వ్యక్తీకరణ ఒక Enum లేదా స్ట్రింగ్ , అలాగే కొన్ని ఆదిమ రకాలు కావచ్చు .
• డిఫాల్ట్ బ్లాక్‌ని గుర్తుంచుకోండి . ఊహించని విలువలను నిర్వహించడానికి దీన్ని ఉపయోగించండి.
• పనితీరును ఆప్టిమైజ్ చేయడానికి, అత్యంత సాధారణ విలువలకు సంబంధించిన కోడ్ బ్రాంచ్‌లను స్విచ్ బ్లాక్ ప్రారంభానికి తరలించండి .
• కేస్ స్టేట్‌మెంట్‌ల చివరిలో బ్రేక్ స్టేట్‌మెంట్‌లను తొలగించడం ద్వారా మీ "ఆప్టిమైజేషన్"లో చిక్కుకోకండి - అటువంటి కోడ్ అర్థం చేసుకోవడం కష్టం మరియు ఫలితంగా నిర్వహించడం కష్టం.