జావాలో కంటిన్యూ స్టేట్మెంట్ ఏమిటి?

నియంత్రణ ప్రకటనలు యొక్క ప్రాథమిక అంశాలు ఇది ప్రాథమికంగా ప్రోగ్రామ్ యొక్క సున్నితమైన ప్రవాహాన్ని అనుమతిస్తుంది. లూప్ యొక్క తదుపరి పునరావృతానికి వెళ్లడానికి, మేము జావా కంటిన్యూ స్టేట్మెంట్‌ను ఉపయోగించుకుంటాము. ఈ ప్రకటన ప్రోగ్రామ్ యొక్క ప్రస్తుత ప్రవాహాన్ని కొనసాగిస్తుంది మరియు పేర్కొన్న స్థితిలో కోడ్ యొక్క కొంత భాగాన్ని దాటవేస్తుంది.

• జావాలో కంటిన్యూ స్టేట్మెంట్ అంటే ఏమిటి?
• సింటాక్స్
• జావా యొక్క ఫ్లో రేఖాచిత్రం స్టేట్మెంట్ కొనసాగించండి
• స్టేట్మెంట్ ఉదాహరణలు కొనసాగించండి
  • • లూప్ ఉంటే
    • లూప్ కోసం
    • లూప్ అయితే
    • డు-లూప్

ప్రారంభిద్దాం.

జావాలో కంటిన్యూ స్టేట్మెంట్ అంటే ఏమిటి?

జావా కంటిన్యూ స్టేట్మెంట్ a లోపల మాత్రమే అనుమతించబడుతుంది . కొనసాగించినప్పుడు, లూప్ బాడీ యొక్క ప్రస్తుత పునరావృతం ముగుస్తుంది మరియు లూప్ యొక్క తదుపరి పునరావృతంతో అమలు కొనసాగుతుంది. సరళంగా చెప్పాలంటే, ఇది ప్రోగ్రామ్ యొక్క ప్రవాహాన్ని కొనసాగిస్తుంది మరియు మిగిలిన కోడ్‌ను నిర్దిష్ట స్థితిలో దాటవేస్తుంది. రియల్ టైమ్ ఉదాహరణ సహాయంతో జావాలో స్టేట్మెంట్ కొనసాగించడాన్ని అర్థం చేసుకుందాం.

ఉదాహరణ (ఇన్‌కమింగ్ కాల్ మరియు అలారం):

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

జావాలో mvc అప్లికేషన్ ఉదాహరణ

ఇప్పుడు జావా కంటిన్యూ స్టేట్మెంట్ ప్రదర్శించడానికి సింటాక్స్ చూద్దాం.

జావా యొక్క సింటాక్స్ కొనసాగించండి:

if (conditition) {continue}

వాక్యనిర్మాణం సెమికోలన్ తరువాత ‘కొనసాగించు’ కీవర్డ్.

ముందుకు వెళుతున్నప్పుడు, జావాలో ఈ కొనసాగింపు ప్రకటన ఎలా పనిచేస్తుందో చూద్దాం.

జావా కంటిన్యూ స్టేట్మెంట్ యొక్క ఫ్లో రేఖాచిత్రం

ఈ ఫ్లోచార్ట్‌లో, కోడ్ క్రింది దశల్లో స్పందిస్తుంది:

1. అన్నింటిలో మొదటిది, ఇది పరిస్థితిని తనిఖీ చేసే లూప్‌లోకి ప్రవేశిస్తుంది.లూప్ పరిస్థితి తప్పు అయితే, అది నేరుగా లూప్ నుండి నిష్క్రమిస్తుంది.
2. ఆ తరువాత అది ‘కొనసాగించు’ స్టేట్‌మెంట్ కోసం తనిఖీ చేస్తుంది. అది ఉన్నట్లయితే, ఆ తరువాత ఉన్న స్టేట్‌మెంట్‌లు లూప్ యొక్క అదే పునరావృతంలో అమలు చేయబడవు.
3. ‘కొనసాగించు’ స్టేట్‌మెంట్ లేకపోతే, ఆ తర్వాత అన్ని స్టేట్‌మెంట్‌లు అమలు చేయబడతాయి.

స్టేట్మెంట్ ఉదాహరణలు కొనసాగించండి

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

స్టేట్మెంట్ కొనసాగించండి - లూప్ అయితే

పబ్లిక్ క్లాస్ ContinueExample {(int i = 0 i కోసం పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ అర్గ్స్ []) {<=5 i++) { if (i==2) { continue //skips the rest of the statement } System.out.print(i+' ') } } } 

అవుట్పుట్: 0 1 3 4 5

వివరణ : పై అవుట్పుట్ 2 మినహా అన్ని సంఖ్యలను ఆలస్యం చేస్తుంది. ఎప్పుడు ఎదురైంది, ఇది తదుపరి పునరావృతానికి దూకుతుంది, ప్రస్తుత పునరుక్తి కోసం స్టేట్‌మెంట్‌లను దాటవేస్తుంది. “కొనసాగించు” నిర్మాణం ఉపయోగించినప్పుడు ఇది మిగిలిన కోడ్‌ను దాటవేస్తుంది.

స్టేట్మెంట్ ఉదాహరణను కొనసాగించండి - లూప్ కోసం

కోసం వారు ఒక భాగాన్ని మళ్ళించాల్సిన అవసరం వచ్చినప్పుడు లూప్ ఉపయోగించబడుతుంది చాలా సార్లు. పునరావృతాల సంఖ్య నిర్ణయించబడిన సందర్భాల్లో ఇది ప్రత్యేకంగా ఉపయోగించబడుతుంది! దిగువ ఉదాహరణ కోడ్‌తో దీన్ని అర్థం చేసుకుందాం:

పబ్లిక్ క్లాస్ ContinueExample {(int i = 0i) కోసం పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్)<=5i++){ if(i==2){ continue } System.out.println(i) } } } 

అవుట్పుట్:
0
ఒకటి
3
4
5

వివరణ: పై అవుట్పుట్ 2 మినహా అన్ని సంఖ్యలను ప్రదర్శిస్తుంది.

స్టేట్మెంట్ ఉదాహరణను కొనసాగించండి- లూప్ అయితే

ది జావా లూప్ అయితే ప్రోగ్రామ్ యొక్క కొంత భాగాన్ని మళ్లీ మళ్లీ మళ్ళించడానికి ఉపయోగిస్తారు. పునరావృత సంఖ్య పరిష్కరించబడకపోతే, మీరు లూప్ అయితే ఉపయోగించవచ్చు. ఇప్పుడు లూప్‌తో స్టేట్మెంట్ ఉదాహరణను కొనసాగించడాన్ని అర్థం చేసుకుందాం. క్రింది కోడ్‌ను చూడండి:

పబ్లిక్ క్లాస్ ContinueExample {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ అర్గ్స్ []) {int i = 10 అయితే (i> = 0) {if (i == 5) {i-- continue} System.out.print (i + '') i--}}}

అవుట్పుట్ : 10 9 8 7 6 4 3 2 1 0

స్టేట్మెంట్ ఉదాహరణను కొనసాగించండి - లూప్ చేస్తున్నప్పుడు చేయండి

డు-లూప్ మాదిరిగానే ఉంటుంది లూప్ అయితే, ఇది ఒక అసమానతను కలిగి ఉంటుంది: లూప్‌లో ఉన్నప్పుడు, లూప్ యొక్క శరీరాన్ని అమలు చేయడానికి ముందు పరిస్థితిని అంచనా వేస్తారు లూప్ యొక్క శరీరం అమలు చేసిన తర్వాత పరిస్థితి అంచనా వేయబడుతుంది. దిగువ కోడ్‌ను చూడండి:

పబ్లిక్ క్లాస్ ContinueExample {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ అర్గ్స్ []) {int i = 1 do {if (i == 5) {i ++ continue} System.out.print (i + '') i ++} అయితే (i<10) } }

అవుట్పుట్ : 1 2 3 4 6 7 8 9

దీనితో, మేము జావా ఆర్టికల్లోని ఈ కంటిన్యూ స్టేట్మెంట్స్ ముగింపుకు వచ్చాము. ప్రోగ్రామ్‌ను సమర్థవంతంగా మరియు యూజర్ ఫ్రెండ్లీగా చేయడానికి జావాలోని కంట్రోల్ స్టేట్‌మెంట్‌లను సమర్థవంతంగా ఉపయోగించాలి.

ఎడురేకా పారిశ్రామిక అవసరాలు మరియు డిమాండ్ల ప్రకారం నిపుణులచే నిర్వహించబడుతుంది. ఈ శిక్షణ కోర్ జావా & జె 2 ఇఇ యొక్క ప్రాథమిక మరియు అధునాతన అంశాలతో పాటు హైబర్నేట్, స్ప్రింగ్, & ఎస్ఓఏ వంటి ప్రసిద్ధ ఫ్రేమ్‌వర్క్‌లపై సమగ్ర జ్ఞానాన్ని కలిగి ఉంటుంది. ఈ కోర్సులో, మీరు జావా అర్రే, జావా ఓఓపిలు, జావా ఫంక్షన్, జావా లూప్స్, జావా కలెక్షన్స్, జావా థ్రెడ్, జావా సర్వ్లెట్ మరియు వెబ్ సర్వీసెస్ వంటి పరిశ్రమల వినియోగ సందర్భాలను ఉపయోగించి నైపుణ్యాన్ని పొందుతారు.

పైథాన్ __init__ తరగతి

మాకు ప్రశ్న ఉందా? దయచేసి 'జావాలో స్టేట్మెంట్ కొనసాగించు' వ్యాసం యొక్క వ్యాఖ్యల విభాగంలో పేర్కొనండి మరియు మేము మిమ్మల్ని సంప్రదిస్తాము.