జెనరిక్స్: సూపర్, విస్తరిస్తుంది, జాబితా

"ఇప్పుడు కొత్త, ఆసక్తికరమైన అంశం కోసం: వైల్డ్‌కార్డ్‌లు."

"ముఖ్యంగా, ఇది దేనికైనా సరిపోయే «*» నమూనా లాంటిది."

"అయితే మొదటి నుండి ప్రారంభిద్దాం."

"మీకు వారియర్ క్లాస్ ఉందని మరియు ఇద్దరు యోధులలో ఎవరు బలంగా ఉన్నారో నిర్ణయించే పద్ధతి ఉందని ఊహించుకోండి. ఇది ఎలా ఉంటుందో ఇక్కడ ఉంది:"

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);

"మ్యాజిక్ వారియర్ మరియు ఆర్చర్ వారియర్ ఇద్దరూ వారియర్‌ను వారసత్వంగా పొందారు. ."

"ఇది చాలా సరళమైనది, కానీ ఉదాహరణకు, ఇది చేస్తుంది."

"అలాగే."

"ఇప్పుడు మీరు అనేక మంది యోధులు పోరాటంలో చేరిన పరిస్థితికి ఇదే పద్ధతిని చేయాలని నిర్ణయించుకున్నారనుకోండి."

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!

"కానీ ఇక్కడ మీరు సంకలనం లోపాన్ని ఎదుర్కొన్నారు మరియు తప్పు ఏమి కావచ్చనే దానిపై అయోమయంలో ఉన్నారు."

"విషయం ఏమిటంటే మ్యాజిక్‌వారియర్ వారియర్‌ను వారసత్వంగా పొందుతుంది మరియు మ్యాజిక్‌వారియర్ వస్తువులను ఫైట్ (వారియర్, వారియర్) పద్ధతికి పంపవచ్చు."

"కానీ జాబితా<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<?>

"అవి రెండూ ఒకే విషయాన్ని సూచిస్తాయి, కాబట్టి రెండవ సంస్కరణ సాధారణంగా ఉపయోగించబడుతుంది."

"ఈరోజుకి అంతే."

"ధన్యవాదాలు, ఎల్లీ. నేను ఈ రోజు చాలా నేర్చుకున్నాను."