ஜெனரிக்ஸ்: சூப்பர், நீட்டிப்புகள், பட்டியல்

"இப்போது ஒரு புதிய, சுவாரஸ்யமான தலைப்பு: வைல்டு கார்டுகள்."

"அடிப்படையில், இது எதற்கும் பொருந்தக்கூடிய «*» மாதிரியானது."

"ஆனால் ஆரம்பத்திலிருந்தே ஆரம்பிக்கலாம்."

"உங்களிடம் ஒரு போர்வீரர் வகுப்பு மற்றும் இரண்டு போர்வீரர்களில் யார் வலிமையானவர் என்பதை தீர்மானிக்கும் முறை உள்ளது என்று கற்பனை செய்து பாருங்கள். இது எப்படி இருக்கும்:"

class WarriorManager
{
 public static boolean fight(Warrior w1, Warrior w2)
 {
  return w1.power > w2.power;
 }
}

MagicWarrior mag = new MagicWarrior();
ArcherWarrior archer = new ArcherWarrior();

boolean isMagicCooler = WarriorManager.fight(mag, archer);

"MagicWarrior மற்றும் ArcherWarrior இருவரும் வாரியரைப் பெற்றனர். ."

"இது கொஞ்சம் எளிமையானது, ஆனால் ஒரு உதாரணத்திற்கு, அது செய்யும்."

"சரி."

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

class WarriorManager
{
 public static boolean fight(Warrior w1, Warrior w2)
 {
  return w1.power > w2.power;
 }

 public static boolean fight(List<Warrior> w1, List<Warrior> w2)
 {
  return …
 }
}

ArrayList<MagicWarrior> magi = new ArrayList<MagicWarrior>();
for(int i = 0; i < 10; i++)
 magi.add(new MagicWarrior());

ArrayList<ArcherWarrior> archers = new ArrayList<ArcherWarrior>();
for(int i = 0; i < 10; i++)
 archers.add(new ArcherWarrior());

boolean isMagicCooler = WarriorManager.fight(magi, archers); // Compilation error!

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

"விஷயம் என்னவென்றால், மேஜிக்வாரியர் வாரியரைப் பெறுகிறார் , மேலும் மேஜிக்வாரியர் பொருட்களை சண்டை (வாரியர், வாரியர்) முறைக்கு அனுப்பலாம்."

"ஆனால் List<MagicWarior> லிஸ்ட்<வாரியர்> மரபுரிமையாக இல்லை . எனவே, நீங்கள் அதை அங்கு அனுப்ப முடியாது!"

"இது மரபுரிமையாக இல்லை என்று நீங்கள் என்ன சொல்கிறீர்கள்?"

"அதாவது: ஒன்று பட்டியல் மற்றும் மற்றொன்று பட்டியல், ஆனால் அவை வகை அளவுருக்கள் உள்ளன."

"நீங்க சொல்றது சரிதான். எப்படியோ நான் அதை உடனே கவனிக்கவில்லை. அப்போ இந்தப் பிரச்சனைக்கு ஏற்கனவே தீர்வு உண்டா?"

"ஆம். நீங்கள் மிகவும் சிக்கலான கட்டமைப்பைப் பயன்படுத்த வேண்டும். இது எப்படித் தெரிகிறது:"

class WarriorManager
{
 public static boolean fight(Warrior w1, Warrior w2)
 {
  return w1.power > w2.power;
 }

 public static boolean fight(List<? extends Warrior> w1, List<? extends Warrior> w2)
 {
  return …
 }
}

"தி «? நீட்டிக்கிறது வாரியர்» பகுதி என்றால் "வாரியரைப் பெற்ற எந்த வகையும்""

"வேறு வார்த்தைகளில் கூறுவதானால், இப்போது நீங்கள் ஒரு பட்டியல்<MagicWarrior> மற்றும் ஒரு பட்டியல்<ArcherWarrior> ஐ அனுப்பலாம், மேலும் எல்லாம் வேலை செய்யும்."

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

"நானும் அப்படித்தான் உணர்கிறேன்."

"ஆனால் வாரியரைப் பெறுவது எனக்குத் தேவையில்லை என்றால் என்ன செய்வது? எந்த வகை அளவுருவுடன் எந்த பட்டியலையும் நான் முறைக்கு அனுப்ப விரும்பினால் என்ன செய்வது? அது அனுமதிக்கப்படுமா?"

"ஆம், அதைச் செய்வதற்கு இரண்டு வகையான குறிப்புகள் உள்ளன:"

List<? extends Object>

List<?>

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

"இன்னைக்கு அவ்வளவுதான்."

"நன்றி, எல்லி. நான் இன்று நிறைய கற்றுக்கொண்டேன்."