నిజంగా ఏమి జరుగుతుంది (అంటే కంపైలర్ తరగతుల నుండి ఏమి ఉత్పత్తి చేస్తుంది)

"హాయ్, అమిగో! మీ కోసం ఇక్కడ కొంత సమాచారం ఉంది."

"కంపైలర్ వాస్తవానికి అన్ని అనామక తరగతులను సాధారణ అంతర్గత తరగతులుగా మారుస్తుందని నేను ఇప్పటికే మీకు చెప్పాను."

"అవును. వారి పేర్లు సంఖ్యలు అని కూడా నాకు గుర్తుంది: 1, 2, 3, మొదలైనవి."

"సరిగ్గా. అయితే ఇక్కడ మరో సూక్ష్మభేదం ఉంది."

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

"మేము దీనితో ప్రారంభిస్తాము:"

class Car
{
 public ArrayList createPoliceCars(int count)
 {
  ArrayList result = new ArrayList();

  for(int i = 0; i < count; i++)
  {
 final int number = i;
   result.add(new Car()
    {
     public String toString()
     {
      return ""+number;
     }
    });
  }
  return result;
 }
}

"మరియు కంపైలర్ దీన్ని ఉత్పత్తి చేస్తుంది:

class Car
{
 public ArrayList createPoliceCars(int count)
 {
  ArrayList result = new ArrayList();

  for(int i = 0; i < count; i++)
  {
   final int number = i;
   result.add(new Anonymous2 (number));
  }
   return result;
  }

 class Anonymous2
 {
  final int number;
  Anonymous2(int number)
 {
  this.number = number;
 }

  public String toString()
  {
   return ""+ number;
  }
 }
}

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

"ఇప్పుడు రెండవ పాయింట్. toString() పద్ధతి పాస్ చేయబడిన వేరియబుల్‌ని ఉపయోగిస్తుంది. దీనిని సాధించడానికి, ఇది అవసరం:"

ఎ) ఉత్పత్తి చేయబడిన తరగతి లోపల దాన్ని సేవ్ చేయండి

బి) దానిని కన్స్ట్రక్టర్‌కు జోడించండి.

"అర్థమైంది. పద్ధతుల లోపల డిక్లేర్డ్ చేయబడిన తరగతులు ఎల్లప్పుడూ వేరియబుల్స్ కాపీలను ఉపయోగిస్తాయి."

"సరిగ్గా!"

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

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

"నేను అంగీకరిస్తున్నాను. అనామక స్థానిక తరగతులు ఇప్పటికీ చాలా కూల్‌గా ఉన్నాయి."

"నేను మెథడ్ లోపల లోకల్ క్లాస్‌ని డిక్లేర్ చేసి, అందులో మెథడ్ వేరియబుల్స్ ఉపయోగిస్తే, కంపైలర్ వాటిని కూడా క్లాస్‌కి జోడిస్తుందా?"

"అవును, ఇది వారిని తరగతికి మరియు దాని కన్స్ట్రక్టర్‌కు జోడిస్తుంది."

"అదే నేననుకున్నది."