జావాలో, స్విచ్ స్టేట్‌మెంట్ వినియోగదారులను కాంపాక్ట్, సంక్షిప్త, స్పష్టమైన మరియు చదవగలిగే కోడ్‌ని అమలు చేయడానికి అనుమతిస్తుంది. if-elseతో పోలిస్తే ఇది బలమైన మరియు అత్యంత శక్తివంతమైన ప్రోగ్రామింగ్ స్టేట్‌మెంట్‌లలో ఒకటి. కేసుల సంఖ్య పరిమితం అయితే, మేము if-else స్టేట్‌మెంట్‌ని ఉపయోగించవచ్చు. అయితే, కేస్ నంబర్‌లు పెద్ద పరిమాణంలో ఉంటే, స్విచ్ కేస్ స్టేట్‌మెంట్‌ని ఉపయోగించడం మంచిది.
ఈ ట్యుటోరియల్ జావాలో స్విచ్ స్టేట్‌మెంట్‌ను ఉపయోగించడం గురించి మాట్లాడుతుంది.
జావాలో స్విచ్ కేస్ స్టేట్‌మెంట్‌లను ఎలా ఉపయోగించాలి?
స్విచ్ స్టేట్‌మెంట్ అనేది if, else if వంటి వివిధ కండిషన్ స్టేట్‌మెంట్. ఇది అన్ని పేర్కొన్న కండిషన్ కోడ్ బ్లాక్‌ల నుండి ఒక స్టేట్‌మెంట్‌ను మాత్రమే అమలు చేస్తుంది. ఇది enums, strings, int, short, long, byte మరియు అనేక ఇతర వాటితో వ్యవహరిస్తుంది. జావాలో స్విచ్ స్టేట్‌మెంట్‌ను ఉపయోగించడానికి, మేము దిగువ వాక్యనిర్మాణాన్ని అందించాము.
వాక్యనిర్మాణం
మారండి ( వ్యక్తీకరణ ) {కేసు విలువ1 :
బ్రేక్ ;
కేసు విలువ2 :
బ్రేక్ ;
......
డిఫాల్ట్ :
}
పై వాక్యనిర్మాణంలో:
- ' మారండి ” అనేది ఒక్కసారి మాత్రమే అమలు చేయబడిన వ్యక్తీకరణ.
- ' కేసు ” పరిస్థితిని నిర్ణయిస్తుంది. పేర్కొన్న వ్యక్తీకరణ యొక్క విలువ ప్రతి సందర్భంతో పోల్చబడుతుంది.
- ' బ్రేక్ ” అనేది షరతును ముగించడానికి ఉపయోగించే ఐచ్ఛిక కీవర్డ్.
- ' డిఫాల్ట్ ” నిర్వచించిన షరతు సరిపోలనప్పుడు కేసు అమలు చేయబడుతుంది.
ఉదాహరణ
ఈ పేర్కొన్న ఉదాహరణలో, మేము పరిస్థితిని సరిపోల్చడానికి స్విచ్ కేస్ స్టేట్‌మెంట్‌ను ఉపయోగిస్తాము. అలా చేయడానికి, ముందుగా, సంఖ్యా డేటా రకంతో సంఖ్యను ప్రకటించండి మరియు మీ స్పెసిఫికేషన్ ప్రకారం విలువను కేటాయించండి:
int ఒకదానిపై = 23 ;
ఇక్కడ:
- స్విచ్ స్టేట్‌మెంట్‌ను ఉపయోగించుకోండి మరియు '' సహాయంతో షరతులను జోడించండి కేసు ” కీవర్డ్.
- అప్పుడు, 'ని ఉపయోగించండి println() ”సంఖ్య పేర్కొన్న షరతుతో సరిపోలితే కన్సోల్‌లో అవుట్‌పుట్‌ను ప్రింట్ చేసే పద్ధతి.
- ఇంకా, డిఫాల్ట్ స్టేట్‌మెంట్ ఐచ్ఛికం. సంఖ్య ఏదైనా షరతుతో సరిపోలకపోతే, అది డిఫాల్ట్ విలువను ముద్రిస్తుంది:
కేసు 1 : వ్యవస్థ . బయటకు . println ( 'పదిహేను' ) ;
బ్రేక్ ;
కేసు 2 : వ్యవస్థ . బయటకు . println ( '25' ) ;
బ్రేక్ ;
కేసు 3 : వ్యవస్థ . బయటకు . println ( '35' ) ;
బ్రేక్ ;
డిఫాల్ట్ : వ్యవస్థ . బయటకు . println ( 'ఉనికిలో లేదు' ) ;
}
దిగువ చిత్రంలో, డిక్లేర్డ్ నంబర్ ఏ షరతుతో సరిపోలడం లేదని గమనించవచ్చు. అందుకే ఇది కన్సోల్‌లో డిఫాల్ట్ విలువను ముద్రిస్తుంది:
స్విచ్ కేస్ స్టేట్‌మెంట్‌ల యొక్క మరొక ఉదాహరణ చూద్దాం. అలా చేయడానికి, వేరియబుల్‌ని ప్రారంభించండి:
int రోజు = 5 ;ప్రతి కేస్ స్టేట్‌మెంట్‌తో నంబర్‌ను సరిపోల్చే స్విచ్ స్టేట్‌మెంట్‌ను ఉపయోగించండి. సంఖ్య ఏదైనా షరతుతో సరిపోలితే, అది డిస్‌ప్లేపై అవుట్‌పుట్‌ను ముగించి ప్రింట్ చేస్తుంది. ఇతర సందర్భంలో, డిఫాల్ట్ విలువ కన్సోల్‌లో ముద్రించబడుతుంది:
మారండి ( రోజు ) {కేసు 0 :
వ్యవస్థ . బయటకు . println ( 'ఈరోజు సోమవారం' ) ;
బ్రేక్ ;
కేసు 1 :
వ్యవస్థ . బయటకు . println ( 'ఈరోజు మంగళవారం' ) ;
బ్రేక్ ;
కేసు 2 :
వ్యవస్థ . బయటకు . println ( 'ఈ రోజు బుధవారం' ) ;
బ్రేక్ ;
కేసు 3 :
వ్యవస్థ . బయటకు . println ( 'ఈ రోజు గురువారము' ) ;
బ్రేక్ ;
కేసు 4 :
వ్యవస్థ . బయటకు . println ( 'ఈ రోజు శుక్రవారం' ) ;
బ్రేక్ ;
కేసు 5 :
వ్యవస్థ . బయటకు . println ( 'ఈరోజు శనివారం' ) ;
బ్రేక్ ;
కేసు 6 :
వ్యవస్థ . బయటకు . println ( 'ఈరోజు ఆదివారం' ) ;
బ్రేక్ ;
}
పేర్కొన్న రోజు విలువ 'తో సరిపోలినందున 5 ” సందర్భంలో, దాని సంబంధిత కోడ్ బ్లాక్ అమలు చేయబడింది.
ముగింపు
జావాలో స్విచ్ కేస్ స్టేట్‌మెంట్‌ను ఉపయోగించడానికి, ముందుగా, డేటా రకంతో వేరియబుల్‌ను ప్రారంభించండి మరియు విలువను కేటాయించండి. ఆపై, ప్రతి కేసుతో సంఖ్యను సరిపోల్చే స్విచ్ కేస్ స్టేట్‌మెంట్‌ను ఉపయోగించండి. నంబర్ షరతుతో సరిపోలితే, ఆ సంఖ్య కన్సోల్ స్క్రీన్‌పై ప్రదర్శించబడుతుంది. ఈ పోస్ట్ జావాలో స్విచ్ కేస్ స్టేట్‌మెంట్‌ను ఉపయోగించే పద్ధతిని పేర్కొంది.