పునరావృతం

"హాయ్, అమిగో. ఈరోజు బిలాబో మీకు రికర్షన్ గురించి చెబుతాడు."

మీకు తెలిసినట్లుగా, జావాలో కొన్ని పద్ధతులు ఇతర పద్ధతులను పిలుస్తారు. అదనంగా, ఒక పద్ధతిని పిలిచినప్పుడు, నిర్దిష్ట ఆర్గ్యుమెంట్‌లు దానికి పంపబడతాయి, అయితే అది నడుస్తున్నప్పుడు పద్ధతి యొక్క స్థానిక వేరియబుల్స్ నిర్దిష్ట విలువలను తీసుకుంటాయి.

"ఉహూ."

"మరియు మీకు తెలిసినట్లుగా, వివిధ పద్ధతుల అంతర్గత వేరియబుల్స్ ఒకదానికొకటి స్వతంత్రంగా ఉంటాయి."

"ఉహూ."

"కాబట్టి ఒక పద్ధతి తనను తాను పిలుచుకునే పరిస్థితిని ఊహించుకోండి. దీనిని రికర్షన్ అంటారు. ఉదాహరణకు:"

public static void main(String[] args)
{
 countDown(10);
}

public static void countDown(int x)
{
 if (x <= 0)
  System.out.println("Boom!");
 else
 {
  System.out.println(x);
  countDown(x - 1);
 }
}

10
9
8
7
6
5
4
3
2
1
Boom!

"కోడ్‌లో పద్ధతి తనను తాను పిలుస్తుందని నేను చూడగలను, కానీ ఏమి జరుగుతుందో నాకు నిజాయితీగా అర్థం కాలేదు."

"సరే, వేరొక పద్ధతిని పిలిచినప్పుడు అదే విషయం గురించి."

"లేదు, వేరియబుల్స్‌తో ఏమి జరుగుతుందో నేను అడుగుతున్నాను? వాటి విలువలతో? మరియు మనం పద్ధతి నుండి ఎలా నిష్క్రమించాలి? లేదా మనం అన్నింటినీ ఒకేసారి నిష్క్రమించాలా?"

"మంచితనం దయగలది. ఇది చాలా సరళమైనది. తనను తాను పిలిచే పద్ధతి చాలాసార్లు గుణించబడిందని ఊహించుకోండి. అప్పుడు మనకు సారూప్య పరిస్థితి ఉంటుంది:"

public static void main(String[] args)
{
 countDown(10);
}

public static void countDown(int x)
{
 if (x <= 0)
  System.out.println("Boom!");
 else
 {
  System.out.println(x);
  countDown(x - 1);
 }
}

public static void main(String[] args)
{
 countDown1(10);
}

public static void countDown1(int x)
{
 if (x <= 0)
  System.out.println("Boom!");
 else
 {
  System.out.println(x);
  countDown2(x - 1);
 }
}
public static void countDown2(int x)
{
 if (x <= 0)
  System.out.println("Boom!");
 else
 {
  System.out.println(x);
  countDown3(x - 1);
 }
}
public static void countDown3(int x)
{
 if (x <= 0)
  System.out.println("Boom!");
 else
 {
  System.out.println(x);
  countDown4(x - 1);
 }
}

public static void countDown4(int x)
{
 if (x <= 0)
  System.out.println("Boom!");
 else
 {
  System.out.println(x);
  countDown5(x - 1);
 }
}

3
2
1
Boom!

3
2
1
Boom!

"మరో మాటలో చెప్పాలంటే, ఒక పద్ధతిని పిలిచే ప్రతిసారీ (దాని ద్వారా కూడా), ఈ పద్ధతి కోసం డేటాను నిల్వ చేసే కొత్త వేరియబుల్స్ సృష్టించబడతాయి. భాగస్వామ్య వేరియబుల్స్ లేవు."

"ప్రతి కాల్‌తో, మెథడ్ ఆర్గ్యుమెంట్‌ల యొక్క మరొక కాపీ, కొత్త విలువలతో, మెమరీలో సృష్టించబడుతుంది. మనం పాత పద్ధతికి తిరిగి వచ్చినప్పుడు, దాని వేరియబుల్స్ అక్కడ ఉపయోగించబడతాయి. మరో మాటలో చెప్పాలంటే, రికర్షన్ సమయంలో మనం నిజానికి మరొక పద్ధతిని పిలుస్తాము, కానీ మాది అదే కోడ్! "

"నేను చూస్తున్నాను. మరియు అటువంటి పద్ధతుల నుండి నిష్క్రమించడం ఎలా పని చేస్తుంది? బహుశా ఒక ఉదాహరణ?"

"సరే. ఒక ఉదాహరణ వెయ్యి పదాల విలువైనది. "ఇదిగో మీ ఉదాహరణ:"

public static void main(String[] args)
{
 print(3);
}

public static void print(int x)
{
 if (x <= 0)
  System.out.println("Boom!");
 else
 {
  System.out.println(x);
  print(x - 1);
  System.out.println(x);
 }
}

public static void main(String[] args)
{
 print1(3);
}

public static void print1(int x)
{
 if (x <= 0)
  System.out.println("Boom!");
 else
 {
  System.out.println(x);
  print2(x - 1);
  System.out.println(x);
 }
}

public static void print2(int x)
{
 if (x <= 0)
  System.out.println("Boom!");
 else
 {
  System.out.println(x);
  print3(x - 1);
  System.out.println(x);
 }
}

…

3
2
1
Boom!
1
2
3

3
2
1
Boom!
1
2
3

"సరే. నేను అర్థం చేసుకున్నాను. మనకు రికర్షన్ ఎందుకు అవసరం?"

"అసలు టాస్క్‌తో సమానమైన ప్రత్యేక సబ్‌టాస్క్‌లుగా విభజించబడే అనేక, చాలా టాస్క్‌లు ఉన్నాయి. ఉదాహరణకు, మీరు XML ట్రీలోని అన్ని మూలకాల ద్వారా నడవాలి. ప్రతి మూలకం అనేక చైల్డ్ ఎలిమెంట్‌లను కలిగి ఉండవచ్చు మరియు వాటికి వాటి స్వంత పిల్లల అంశాలు."

"లేదా మీరు డైరెక్టరీలో ఉన్న ఫైల్‌ల జాబితాను మరియు దాని అన్ని సబ్‌డైరెక్టరీలను ప్రదర్శించాలి. కాబట్టి మీరు ప్రస్తుత డైరెక్టరీ యొక్క ఫైల్‌లను ప్రదర్శించే పద్ధతిని వ్రాస్తారు. ఆపై అన్ని సబ్‌డైరెక్టరీల ఫైల్‌లను పొందడానికి, మీరు ఒక పద్ధతిని ఉపయోగించి మీ పద్ధతిని కాల్ చేస్తారు. విభిన్న వాదన: ఒక ఉప డైరెక్టరీ."

"ఉదాహరణకి:"

public static void main(String[] args)
{
 printAllFiles(new File("c:/windows/"));
}

public static void printAllFiles(File dir)
{
 for (File file : dir.listFiles())
 {
  if (file.isDirectory())
   printAllFiles(file);
  else
   System.out.println(file.getAbsolutePath());
 }
}

"లైన్ 8 - మేము dir డైరెక్టరీలో అన్ని ఫైల్‌ల (మరియు డైరెక్టరీలు) జాబితాను పొందుతాము."

"లైన్లు 10-11 – ఫైల్ వాస్తవానికి డైరెక్టరీ అయితే, మేము మళ్ళీ printAllFiles అని పిలుస్తాము , కానీ ఈసారి మరొక వాదనతో: ఉప డైరెక్టరీ."

"లైన్ 13 - మేము ప్రస్తుత ఫైల్ పేరును ప్రదర్శిస్తాము."

"సరే. నేను అర్థం చేసుకున్నాను. ధన్యవాదాలు, బిలాబో."