அநாமதேய உள் வகுப்புகள் மற்றும் எடுத்துக்காட்டுகள்

"வணக்கம், அமிகோ!"

"ஆனால் நாங்கள் ஏற்கனவே ஹலோ சொல்லிவிட்டோம், எல்லி!"

"ஏய், அத்தையிடம் வாக்குவாதம் செய்யாதே. 31 ஆம் நூற்றாண்டில், நீங்கள் யாரையாவது அரை மணி நேரத்திற்கு மேல் பார்க்கவில்லை என்றால், மீண்டும் வணக்கம் சொல்வது வழக்கம். எனவே உங்கள் அணுகுமுறையை எனக்குக் கொடுக்க வேண்டாம்!"

"எப்படியும், மற்றொரு சுவாரஸ்யமான தலைப்புக்கான நேரம் இது: ரோபோ இனப்பெருக்கம்!"

"ஓ_ஓ."

"சும்மா வேடிக்கை, புதிய தலைப்பு அநாமதேய உள் வகுப்புகள் ."

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

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 பொருளை உருவாக்கி அதன் தொடக்க() முறையை செயல்படுத்துகிறோம்."

"JVM ஒரு புதிய நூலை உருவாக்கும், அது TigerThread இன் ரன் முறை அழைக்கப்படும்போது இயங்கத் தொடங்கும்."

"இந்த முறை எங்கள் ரன் முறையை அழைக்கிறது : tigerRun ."

"நான் இதற்கு முன்பு நூல்களுடன் பணிபுரிந்தேன், எனவே இது நேரடியாகத் தெரிகிறது."

"நாம் முறைகளுக்கு டைகர்ரன் மற்றும் டைகர்ஸ்டார்ட் என்று பெயரிட வேண்டுமா?"

"இல்லை, நாங்கள் அவர்களை ரன் மற்றும் ஸ்டார்ட் என்று அழைத்திருக்கலாம், ஆனால் நாங்கள் த்ரெட்டைப் பெறவில்லை என்பதை நான் நிரூபிக்க விரும்பினேன். ஒரு விளக்கம் குழப்பமாக இருந்திருக்கலாம்."

"சரி. பிறகு புரிந்தது என்று நினைக்கிறேன். ஆனால் tigerStart இரண்டாவது முறையாக அழைக்கப்பட்டால், நாம் இரண்டாவது Thread ஆப்ஜெக்டை உருவாக்கி தொடங்குவோம். அதாவது "ஒரு புலி இரண்டு வெவ்வேறு இழைகளில் இயங்கும்" என்று அர்த்தம் இல்லையா? "

"சரி, நீங்கள் கூர்மையாக இல்லையா! நீங்கள் சொல்வது சரிதான், அது நல்லதல்ல. குறியீட்டை இப்படி மாற்றி எழுதுவோம்:"

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 பொருள் உருவாக்கப்படும்.

வேறு வார்த்தைகளில் கூறுவதானால், ஒரு முறையை மேலெழுதுவதற்கும் ஒரு பொருளை உருவாக்குவதற்கும் நாங்கள் முழு குறியீட்டையும் எழுதினோம்.

கட்டமைப்பாளர்களின் கண்டுபிடிப்பைப் பற்றி நான் எப்படிப் பேசினேன் என்பது உங்களுக்கு நினைவிருக்கிறதா?

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», முதலியன பெயரிடப்படுகின்றன."