ஜெனரிக்ஸ்: வகுப்பு

"ஹாய்! ஜெனரிக்ஸ் பற்றிய எல்லியின் பாடத்தைத் தொடரப் போகிறேன். கேட்கத் தயாரா?"

"ஆம்."

"அப்படியானால் ஆரம்பிக்கலாம்."

"நீங்கள் தெரிந்து கொள்ள வேண்டிய முதல் விஷயம் என்னவென்றால், ஒரு வகுப்பின் முறைகள் அவற்றின் சொந்த வகை அளவுருக்களையும் கொண்டிருக்கலாம்."

"எனக்கு தெரியும்."

"இல்லை, நான் குறிப்பாக அவற்றின் சொந்த வகை அளவுருக்களைக் குறிக்கிறேன்: "

class Calculator
{
  T add(T a, T b); // Add
  T sub(T a, T b); // Subtract
  T mul(T a, T b); // Multiply
  T div(T a, T b); // Divide
}

"இந்த வகை அளவுருக்கள் குறிப்பாக முறைகளுடன் தொடர்புடையவை. வகுப்பில் அளவுருக்கள் இல்லை. நீங்கள் இந்த முறைகளை நிலையானதாக அறிவிக்கலாம் மற்றும் பொருள் இல்லாமல் அவற்றை அழைக்கலாம்."

"நான் பார்க்கிறேன். முறைகளில் உள்ள வகை அளவுருக்களின் புள்ளி வகுப்புகளுக்கு சமமானதா?"

"ஆமாம். ஆனா ஏதோ புதுசா இருக்கு."

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

public void doSomething(List<? extends MyClass> list)
{
 for(MyClass object : list)
 {
  System.out.println(object.getState()); // Everything works well here.
 }
}

"ஆனால் சேகரிப்பில் ஒரு புதிய உருப்படியைச் சேர்க்க விரும்பினால் என்ன செய்வது:"

public void doSomething(List<? extends MyClass> list)
{
 list.add(new MyClass()); // Error!
}

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

"ஆமா, அதுக்கு என்ன செய்யலாம்?"

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

"தொடரியல் கிட்டத்தட்ட ஒரே மாதிரியாக இருக்கிறது:"

List<? super MyClass> list

ஆனால் நீட்டிப்புகள் மற்றும் சூப்பர் இடையே ஒரு முக்கியமான வேறுபாடு உள்ளது.

"«? டி நீட்டிக்கிறது" என்றால் அந்த வகுப்பு T இன் வழித்தோன்றலாக இருக்க வேண்டும்."

" «? சூப்பர் டி» என்றால் அந்த வகுப்பு T இன் மூதாதையராக இருக்க வேண்டும் என்பதாகும்.

"ஹோலி மோலி. இது எங்கே பயன்படுத்தப்படுகிறது?"

"«? சூப்பர் டி» என்பது டி பொருள்களின் தொகுப்பில் சேர்க்கும் போது பயன்படுத்தப்படுகிறது. இந்த விஷயத்தில், இது டி பொருள்களின் தொகுப்பாக இருக்கலாம் அல்லது டியின் எந்த மூதாதையராகவும் இருக்கலாம்."

"ஆ. AT பொருளை ஒரு குறிப்பு மாறிக்கு ஒதுக்கலாம், அதன் வகை T இன் மூதாதையர்களில் ஏதேனும் உள்ளது"

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

public void doSomething(List<? super MyClass> list)
{
 for(MyClass object : list) // Error!
 {
  System.out.println(object.getState());
 }
}

public void doSomething(List<? super MyClass> list)
{
 list.add(new MyClass()); // Everything works well here.
}

"இப்போது முதல் உதாரணம் வேலை செய்யாது."

"பட்டியல் ஒரு பட்டியல்<பொருள்> (ஆப்ஜெக்ட் என்பது MyClass இன் மிக உயர்ந்த சூப்பர்கிளாஸ்) என்பதால், நாங்கள் பின்வரும் தவறான குறியீட்டை எழுதுகிறோம்:"

List<Object> list; 

for(MyClass object : list) // Error!
{ 
 System.out.println(object.getState()); 
}

"நான் பார்க்கிறேன். சுவாரஸ்யமான பாடத்திற்கு நன்றி."

"நீங்கள் வரவேற்கப்படுகிறீர்கள்."