అనామక అంతర్గత తరగతులు మరియు ఉదాహరణలు

"హాయ్, అమిగో!"

"అయితే మేము ఇప్పటికే హలో చెప్పాము, ఎల్లీ!"

"అరే, మీ అత్తతో వాదించకండి. 31వ శతాబ్దంలో, మీరు అరగంట కంటే ఎక్కువసేపు చూడకపోతే, మళ్ళీ హలో చెప్పడం ఆనవాయితీ. కాబట్టి మీ వైఖరి నాకు ఇవ్వకండి!"

"ఏమైనప్పటికీ, ఇది మరొక ఆసక్తికరమైన అంశం కోసం సమయం: రోబోట్ పునరుత్పత్తి!"

"ఓ_ఓ."

"తమాషాగా, కొత్త అంశం అనామక అంతర్గత తరగతులు ."

"జావాలో, కొన్నిసార్లు అనేక తరగతులను వారసత్వంగా పొందేందుకు మీకు తరగతి అవసరమయ్యే పరిస్థితులు ఉన్నాయి. Java బహుళ వారసత్వానికి మద్దతు ఇవ్వదు కాబట్టి, వారు అంతర్గత తరగతులను ఉపయోగించి ఈ సమస్యను పరిష్కరించారు: మా తరగతిలో, మేము ఒక అంతర్గత తరగతిని ప్రకటించి, తయారు చేస్తాము మనకు ఏ తరగతి కావాలన్నా అది వారసత్వంగా పొందుతుంది. ఇక్కడ ఒక ఉదాహరణ ఉంది:"

class Tiger extends Cat
{
 public void tigerRun()
 {
  .....
 }

 public void startTiger()
 {
  TigerThread thread = new TigerThread();
  thread.start();
 }

 class TigerThread extends Thread
 {
  public void run()
  {
   tigerRun();
  }
 }
}

"మరొక ఉదాహరణలోకి తీయండి:"

దాని రన్ మెథడ్‌ని ఓవర్‌రైడ్ చేయడానికి మాకు థ్రెడ్ క్లాస్ సబ్‌క్లాస్ అవసరం."

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

"సౌలభ్యం కోసం, మేము టైగర్ క్లాస్‌లో రెండు పద్ధతులను నిర్వచించాము: టైగర్‌రన్ మరియు స్టార్ట్‌టైగర్ (ఇవి థ్రెడ్ యొక్క రన్ మరియు స్టార్ట్ పద్ధతులకు సారూప్యంగా ఉంటాయి."

"టైగర్‌స్టార్ట్ పద్ధతిలో, మేము టైగర్‌థ్రెడ్ ఆబ్జెక్ట్‌ను సృష్టిస్తాము మరియు దాని ప్రారంభ() పద్ధతిని అమలు చేస్తాము."

"JVM ఒక కొత్త థ్రెడ్‌ను సృష్టిస్తుంది, అది టైగర్‌థ్రెడ్ యొక్క రన్ పద్ధతిని పిలిచినప్పుడు అమలు ప్రారంభమవుతుంది."

"ఈ పద్ధతి మా రన్ పద్ధతిని పిలుస్తుంది : tigerRun ."

"నేను ఇంతకు ముందు థ్రెడ్‌లతో పనిచేశాను, కాబట్టి ఇది సూటిగా అనిపిస్తుంది."

"మేము పద్ధతులకు టైగర్‌రన్ మరియు టైగర్‌స్టార్ట్ అని పేరు పెట్టాలా?"

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

"సరే. అప్పుడు నేను అర్థం చేసుకున్నాను. కానీ టైగర్‌స్టార్ట్‌ని రెండవసారి పిలిస్తే, మేము రెండవ థ్రెడ్ ఆబ్జెక్ట్‌ని సృష్టించి, ప్రారంభిస్తాము. అంటే మనకు «ఒక పులి రెండు వేర్వేరు థ్రెడ్‌లపై నడుస్తుంది» అని అర్థం కాదా? "

"సరే, మీరు పదునుగా ఉన్నారు కదా! మీరు చెప్పింది నిజమే, అది మంచిది కాదు. కోడ్‌ని ఇలా తిరిగి రాద్దాం:"

class Tiger extends Cat
{
 public void tigerRun()
 {
  .....
 }

 public void startTiger()
 {
  thread.start();
 }

 private TigerThread thread = new TigerThread();

 private class TigerThread extends Thread
 {
  public void run()
  {
   tigerRun();
  }
 }
}

"ఇది చాలా ఖచ్చితమైనది కాదు. మీరు ఇప్పటికీ అలాంటి పద్ధతిని రెండుసార్లు పిలవలేరు. కానీ ఈసారి, మేము కనీసం రెండవ థ్రెడ్‌ని సృష్టించి, అంతా బాగానే ఉన్నట్లు అనిపించేలా చేయము."

"అది నిజమే. రెండోసారి టైగర్ స్టార్ట్ అయినప్పుడు, మీకు మినహాయింపు లభిస్తుంది."

"నేను ఇప్పటికే మీ కంటే మెరుగ్గా తప్పులను గుర్తించాను, ఎల్లీ!"

"అవును, నువ్వు చాలా బాగా చేస్తున్నావు. అప్పుడు అనామక ఇన్నర్ క్లాసులకు వెళ్దాం."

"పైన ఉన్న కోడ్ యొక్క అనేక అంశాలను గమనించండి:"

1) మేము థ్రెడ్ క్లాస్‌ను వారసత్వంగా పొందాము, కానీ ఆచరణాత్మకంగా అక్కడ కోడ్‌ను అమలు చేయలేదు. "మేము థ్రెడ్ క్లాస్‌ను వారసత్వంగా పొందవలసి వచ్చింది" కంటే "దీనిని విస్తరించడానికి మేము దానిని వారసత్వంగా పొందాము".

2) ఒక టైగర్ థ్రెడ్ ఆబ్జెక్ట్ మాత్రమే సృష్టించబడుతుంది.

మరో మాటలో చెప్పాలంటే, ఒక పద్ధతిని భర్తీ చేయడానికి మరియు ఒక వస్తువును సృష్టించడానికి మేము మొత్తం కోడ్‌ని వ్రాసాము.

కన్స్ట్రక్టర్ల ఆవిష్కరణ గురించి నేను ఎలా మాట్లాడానో మీకు గుర్తుందా?

TigerThread thread = new TigerThread();

private class TigerThread extends Thread
{
 public void run()
 {
  tigerRun();
 }
}

Thread thread = new Thread()
{
 public void run()
 {
  tigerRun();
 }
};

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

"మేము నాలుగు విషయాలను ఒకటిగా కలపవచ్చు:"

1) ఉత్పన్నమైన తరగతి యొక్క ప్రకటన

2) పద్ధతి ఓవర్‌రైడింగ్

3) వేరియబుల్ డిక్లరేషన్

4) ఉత్పన్నమైన తరగతి యొక్క ఉదాహరణను సృష్టించడం.

"వాస్తవానికి, మేము చేస్తున్నది రెండు కార్యకలాపాలను కలపడం: ఉత్పన్నమైన తరగతిని ప్రకటించడం మరియు ఆ తరగతి యొక్క ఉదాహరణను సృష్టించడం."

Cat tiger = new Tiger();

class Tiger extends Cat
{
}

Cat tiger = new Cat()
{
};

"సింటాక్స్‌ని మళ్లీ అన్వేషిద్దాం:"

Thread thread = new Thread();

Thread thread = new Thread()
{

};

"మేము కేవలం కొత్త తరగతిని నిర్వచించడం లేదని గమనించండి. మేము వేరియబుల్‌ని సృష్టిస్తున్నాము-చివరలో సెమికోలన్ ఉంది!"

"మరియు మేము రన్ పద్ధతిని భర్తీ చేయాలనుకుంటే, మనం దీన్ని వ్రాయాలి:"

Thread thread = new Thread()
{
 public void run()
  {
   System.out.println("new run-method");
  }
};

"మీరు త్వరగా పట్టుకోండి. బాగా చేసారు!"

"ధన్యవాదాలు. మనకు థ్రెడ్ క్లాస్‌లో భాగం కాని ఇతర పద్ధతులు అవసరమైతే?"

"మీరు వాటిని వ్రాయవచ్చు."

"అజ్ఞాతవాసి అయినప్పటికీ, ఇది పూర్తి స్థాయి అంతర్గత తరగతి:"

Thread thread = new Thread()
{
  public void run()
  {
   printHi();
  }

  public void printHi()
  {
   System.out.println("Hi!");
  }
};

"పూర్తి స్థాయి అంతర్గత తరగతి?"

"కాబట్టి నేను ఔటర్ క్లాస్ యొక్క వేరియబుల్స్ ఉపయోగించవచ్చా?"

"ఖచ్చితంగా."

"మరియు నేను కన్స్ట్రక్టర్‌కి ఏదైనా పంపగలనా?"

"అవును, కానీ సూపర్ క్లాస్ యొక్క కన్స్ట్రక్టర్ కోసం వాదనలు మాత్రమే:"

class Cat
{
 int x, y;
 Cat(int x, int y)
 {
  this.x = x;
  thix.y = y;
 }
}

Cat cat = new Cat(3,4)
{
  public void print()
  {
   System.out.println(x+" "+y);
  }
};

"మేము వేరొకరి కన్స్ట్రక్టర్‌కు మా స్వంత పారామితులను జోడించలేము. కానీ మేము బాహ్య తరగతి యొక్క వేరియబుల్స్‌ను ఉపయోగించవచ్చు, ఇది ఈ లోపాన్ని చక్కగా భర్తీ చేస్తుంది."

"నేను ఇప్పటికీ కన్స్ట్రక్టర్‌కు ఇతర పారామితులను జోడించాల్సిన అవసరం ఉంటే?"

"అప్పుడు ఒక సాధారణ (నాన్-అనామక) అంతర్గత తరగతిని ప్రకటించి దానిని ఉపయోగించండి."

"సరే, నేను దాని గురించి దాదాపు మర్చిపోయాను."

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

"లేదు. ఇది అనామక అంతర్గత తరగతి అవుతుంది. ఈ ఉదాహరణలను చూడండి."

Thread thread = new Thread()
{
  public void run()
  {
   tigerRun();
  }
};

TigerThread thread = new TigerThread();

private class TigerThread extends Thread
{
 public void run()
 {
  tigerRun();
 }
}

static Thread thread = new Thread()
{
  public void run()
  {
   tigerRun();
  }
};

static TigerThread thread = new TigerThread();

private class TigerThread extends Thread
{
 public void run()
 {
  tigerRun();
 }
}

"నేను చూస్తున్నాను. స్టాటిక్ వేరియబుల్ మాత్రమే స్టాటిక్‌గా ఉంటుంది, క్లాస్ కాదు."

"అవును."

"వాస్తవానికి, కంపైలర్ అన్ని అనామక అంతర్గత తరగతులకు అంతర్గత తరగతులను సృష్టిస్తుంది. ఈ తరగతులకు సాధారణంగా «1», «2», «3», మొదలైనవి పేరు పెట్టబడతాయి."