1. break
ప్రకటన
మునుపటి పాఠం నుండి ఒక ఉదాహరణను పరిశీలిద్దాం:
కోడ్ | వివరణ |
---|---|
|
మీరు ఎంటర్ చేసే వరకు ప్రోగ్రామ్ కీబోర్డ్ నుండి ఒక పంక్తిని చదువుతుంది "exit" . |
పదం నమోదు చేయబడే వరకు ప్రోగ్రామ్ కన్సోల్ నుండి పంక్తులను చదువుతుంది exit
. మీరు ఈ పదాన్ని నమోదు చేస్తే, isExit
వేరియబుల్ అవుతుంది true
, లూప్ పరిస్థితి ఉంటుంది మరియు లూప్ ముగుస్తుంది."!isExit
false
break
అటువంటి లాజిక్ను సరళీకృతం చేయడానికి మిమ్మల్ని అనుమతించే ప్రత్యేక ప్రకటన జావాలో ఉంది . లూప్ లోపల స్టేట్మెంట్ break
అమలు చేయబడితే, లూప్ వెంటనే ముగుస్తుంది. ప్రోగ్రామ్ లూప్ను అనుసరించే స్టేట్మెంట్ను అమలు చేయడం ప్రారంభిస్తుంది. ప్రకటన చాలా క్లుప్తంగా ఉంది:
break;
break
మేము ఇప్పుడే చర్చించిన ఉదాహరణను తిరిగి వ్రాయడానికి మీరు స్టేట్మెంట్ను ఎలా ఉపయోగించవచ్చో ఇక్కడ ఉంది :
కోడ్ | వివరణ |
---|---|
|
మీరు ఎంటర్ చేసే వరకు ప్రోగ్రామ్ కీబోర్డ్ నుండి ఒక పంక్తిని చదువుతుంది "exit" . |
2. కొనసాగింపు ప్రకటన
కానీ break
లూప్ ప్రవర్తనను నియంత్రించడానికి మిమ్మల్ని అనుమతించే జావా ప్రకటన మాత్రమే కాదు. జావాలో ప్రకటన కూడా ఉంది continue
. మీరు continue
లూప్ లోపల స్టేట్మెంట్ను అమలు చేస్తే, లూప్ యొక్క ప్రస్తుత పునరావృతం షెడ్యూల్ కంటే ముందే ముగుస్తుంది.
లూప్ బాడీని ఒకసారి అమలు చేయడాన్ని లూప్ యొక్క పునరావృతం అంటారు. స్టేట్మెంట్ continue
లూప్ యొక్క ప్రస్తుత పునరుక్తికి అంతరాయం కలిగిస్తుంది, కానీ break
స్టేట్మెంట్ వలె కాకుండా, ఇది లూప్ను ముగించదు. ప్రకటన కూడా క్లుప్తంగా ఉంది:
continue;
continue
మేము నిర్దిష్ట పరిస్థితుల్లో లూప్ బాడీని 'స్కిప్' చేయాలనుకుంటే లూప్లో స్టేట్మెంట్ చాలా సౌకర్యవంతంగా ఉంటుంది .
1
టాస్క్: మేము నుండి సంఖ్యలను ప్రింట్ చేసే ప్రోగ్రామ్ను వ్రాయాలనుకుంటున్నాము 20
కానీ ద్వారా భాగించబడే సంఖ్యలను దాటవేస్తాము 7
. ఈ కోడ్ ఇలా ఉండవచ్చు.
కోడ్ | వివరణ |
---|---|
|
ప్రోగ్రామ్ నుండి సంఖ్యలను 1 ప్రదర్శిస్తుంది 20 . సంఖ్య ద్వారా భాగించబడినట్లయితే 7 (డివిజన్ యొక్క మిగిలిన భాగం 7 ) 0 , అప్పుడు మేము సంఖ్యను ప్రదర్శించడాన్ని దాటవేస్తాము. |
వాస్తవానికి, ఈ కోడ్ పని చేయదు , ఎందుకంటే i
నంబర్ వద్ద ఎప్పటికీ నిలిచిపోతుంది 7
. అన్నింటికంటే, continue
ప్రకటన రెండు ఇతర ప్రకటనలను దాటవేస్తుంది: System.out.println(i)
మరియు i++
. ఫలితంగా, మనం విలువను చేరుకున్న తర్వాత 7
, వేరియబుల్ i
మారడం ఆగిపోతుంది మరియు మనం అనంతమైన లూప్లో ఉంటాము.
ఈ చాలా సాధారణ తప్పును వివరించడానికి మేము ఉద్దేశపూర్వకంగా ఈ విధంగా కోడ్ని వ్రాసాము. మేము దానిని ఎలా పరిష్కరించాలి?
ఇక్కడ రెండు ఎంపికలు ఉన్నాయి:
ఎంపిక 1:i
అమలు చేయడానికి ముందు మార్చండి continue
, కానీ తర్వాతi % 7
ఎంపిక 2: ఎల్లప్పుడూ i
లూప్ ప్రారంభంలో ఇంక్రిమెంట్. కానీ అప్పుడు i
ప్రారంభ విలువ ఉండాలి 0
.
ఎంపిక 1 | ఎంపిక 2 |
---|---|
|
|