अनामित अंतर्गत वर्ग आणि उदाहरणे

"हाय, अमिगो!"

"पण आम्ही आधीच हॅलो म्हणालो आहे, एली!"

"अहो, काकूंशी वाद घालू नकोस. 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();
  }
 }
}

"चला आणखी एक उदाहरण पाहू:"

आम्हाला थ्रेड क्लासची रन पद्धत ओव्हरराइड करण्यासाठी उपवर्गाची आवश्यकता आहे."

"म्हणूनच टायगर क्लासमध्ये आम्ही टायगरथ्रेड इनर क्लास घोषित केला आहे, जो थ्रेडचा वारसा घेतो आणि रन पद्धत ओव्हरराइड करतो.

"सोयीसाठी, आम्ही टायगर क्लासमध्ये दोन पद्धती परिभाषित केल्या आहेत: टायगररन आणि स्टार्टटाइगर (जे थ्रेडच्या रन आणि स्टार्ट पद्धतीशी समान आहेत."

"tigerStart पद्धतीमध्ये, आम्ही TigerThread ऑब्जेक्ट तयार करतो आणि त्याची start() पद्धत सुरू करतो."

"JVM एक नवीन थ्रेड तयार करेल जो टायगरथ्रेडची रन पद्धत कॉल केल्यावर चालू होईल."

"या पद्धतीला नंतर आमच्या रन पद्धती म्हणतात: tigerRun ."

"मी आधी थ्रेड्सवर काम केले आहे, त्यामुळे हे सरळ वाटते."

"आम्हाला tigerRun आणि tigerStart या पद्धतींची नावे द्यायची आहेत का?"

"नाही, आम्ही त्यांना रन आणि स्टार्ट म्हणू शकलो असतो, परंतु मला हे देखील दाखवायचे होते की आम्हाला थ्रेडचा वारसा मिळत नाही. स्पष्टीकरण अधिक गोंधळात टाकणारे असेल."

"ठीक आहे. मग मला वाटते की मला ते समजले आहे. पण टायगरस्टार्टला दुसऱ्यांदा कॉल केल्यास, आम्ही दुसरा थ्रेड ऑब्जेक्ट तयार करू आणि सुरू करू. याचा अर्थ असा नाही की आमच्याकडे «दोन वेगवेगळ्या धाग्यांवर एक वाघ धावत असेल»? "

"बरं, तू तीक्ष्ण आहेस ना! तू बरोबर आहेस, आणि ते चांगले नाही. चला असा कोड पुन्हा लिहू:"

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) आम्हाला थ्रेड क्लास वारसा मिळाला आहे, परंतु तेथे व्यावहारिकरित्या कोणताही कोड लागू केला नाही. "आम्हाला थ्रेड क्लासचा वारसा घ्यावा लागला" ऐवजी "आम्ही तो वाढवण्यासाठी वारसा घेतला" हे अधिक होते.

२) फक्त एक टायगरथ्रेड ऑब्जेक्ट तयार होईल.

दुसऱ्या शब्दांत, आम्ही फक्त एक पद्धत ओव्हरराइड करण्यासाठी आणि एक ऑब्जेक्ट तयार करण्यासाठी कोडचा संपूर्ण समूह लिहिला.

कन्स्ट्रक्टरच्या शोधाबद्दल मी कसे बोललो ते तुम्हाला आठवते का?

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», इ.