1. రివర్స్ లూప్

జావాలో మరొక రకమైన whileలూప్ ఉంది - do-whileలూప్. ఇది సాధారణ whileలూప్‌తో సమానంగా ఉంటుంది మరియు కేవలం రెండు భాగాలను మాత్రమే కలిగి ఉంటుంది: ఒక "కండిషన్" మరియు "లూప్ బాడీ". పరిస్థితి ఉన్నంత వరకు లూప్ బాడీ మళ్లీ మళ్లీ అమలు చేయబడుతుంది true. సాధారణంగా, do-whileలూప్ ఇలా కనిపిస్తుంది:

do
   statement;
while (condition);

లేదా

do
{
   block of statements
}
while (condition);

లూప్ కోసం while, ఎగ్జిక్యూషన్ యొక్క క్రమం: కండిషన్ , లూప్ బాడీ , కండిషన్ , లూప్ బాడీ , కండిషన్ , లూప్ బాడీ , ...

కానీ do-whileలూప్ కోసం, ఇది కొద్దిగా భిన్నంగా ఉంటుంది: లూప్ బాడీ , కండిషన్ , లూప్ బాడీ , కండిషన్ , లూప్ బాడీ , ...

వాస్తవానికి, whileలూప్ మరియు do-whileలూప్ మధ్య ఉన్న ఏకైక వ్యత్యాసం ఏమిటంటే, లూప్ బాడీ లూప్ కోసం కనీసం ఒక్కసారైనా అమలు చేయబడుతుంది do-while.


do-while2. లూప్ ఉపయోగించడం వల్ల కలిగే ప్రయోజనాలు

do-whileప్రాథమికంగా, లూప్ మరియు లూప్ మధ్య ఉన్న ఏకైక వ్యత్యాసం whileఏమిటంటే, లూప్ యొక్క శరీరంdo-while కనీసం ఒక్కసారైనా అమలు చేయబడుతుంది.

సాధారణంగా, do-whileలూప్ బాడీని అమలు చేయకపోతే లూప్ పరిస్థితిని తనిఖీ చేయడంలో అర్థం లేనప్పుడు లూప్ ఉపయోగించబడుతుంది. ఉదాహరణకు, లూప్ బాడీలో నిర్దిష్ట గణనలను నిర్వహించి , ఆపై కండిషన్‌లో ఉపయోగించినట్లయితే .

ఉదాహరణ:

exitపదాన్ని నమోదు చేసే వరకు ప్రోగ్రామ్ కీబోర్డ్ నుండి పంక్తులను చదువుతుంది

అయితే అయితే చేయండి
String s;
while (true)
{
   s = console.nextLine();
   if (s.equals("exit"))
      break;
}
String s;
do
{
   s = console.nextLine();
}
while (!s.equals("exit"));

లూప్‌లోని breakమరియు స్టేట్‌మెంట్‌లు లూప్‌లో ఉన్న విధంగానే పని చేస్తాయి .continuedo-whilewhile


3. లూప్‌లను పోల్చడం do-while: జావా vs పాస్కల్

మరోసారి, పాస్కల్ లూప్ యొక్క అనలాగ్ను కలిగి ఉంది do-while, కానీ దానిని లూప్ అంటారు repeat-until. అలాగే, ఇది లూప్ నుండి కొద్దిగా భిన్నంగా ఉంటుంది do-while. లూప్‌లో repeat-until, లూప్‌ను ఎప్పుడు కొనసాగించాలో కాకుండా ఎప్పుడు నిష్క్రమించాలో కండిషన్ సూచిస్తుంది.

ఉదాహరణలు:

పాస్కల్ జావా
Repeat
   ReadLn(s);
Until s = 'exit';
String s;
do {
   s = console.nextLine();
}
while ( !s.equals("exit") );

జావాతో పోలిస్తే, పాస్కల్ దీన్ని సూచించే విధానం చాలా అందంగా ఉంది. మేము పాస్కల్ నుండి ఉదాహరణలతో ప్రారంభించాలి, లేకపోతే మీరు నవ్వుతారు.


2
టాస్క్
Java Syntax,  స్థాయిపాఠం
లాక్ చేయబడింది
Cat's finalize method
It's difficult to accidentally lose an object: as long as you have even one reference to an object, it remains alive. But if not, then the object is approached by the finalize method, an unpredictable assassin that works for the Java machine. Let's create this method ourselves: protected void finalize() throws Throwable. The last two words will become clear a little later.