மறுநிகழ்வு

"வணக்கம், அமிகோ. இன்று பிலாபோ உங்களுக்கு மறுநிகழ்வு பற்றிச் சொல்லுவார்."

உங்களுக்கு தெரியும், ஜாவாவில் சில முறைகள் மற்ற முறைகளை அழைக்கின்றன. கூடுதலாக, ஒரு முறை அழைக்கப்படும் போது, ​​குறிப்பிட்ட வாதங்கள் அதற்கு அனுப்பப்படும், ஆனால் முறையின் உள்ளூர் மாறிகள் அது இயங்கும் போது சில மதிப்புகளை எடுக்கும்.

"ஊஹூம்."

"உங்களுக்குத் தெரியும், வெவ்வேறு முறைகளின் உள் மாறிகள் ஒன்றுக்கொன்று சுயாதீனமானவை."

"ஊஹூம்."

"எனவே ஒரு முறை தன்னை அழைக்கும் சூழ்நிலையை கற்பனை செய்து பாருங்கள். இது மறுநிகழ்வு என்று அழைக்கப்படுகிறது. உதாரணமாக:"

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 - தற்போதைய கோப்பின் பெயரைக் காட்டுகிறோம்."

"சரி. புரிந்து கொண்டேன் என்று நினைக்கிறேன். நன்றி, பிலாபோ."