Generics: super, extends, list

"Ngayon para sa isang bago, kawili-wiling paksa: mga wildcard."

"Sa totoo lang, ito ay parang isang «*» pattern na tumutugma sa kahit ano."

"Pero simulan natin sa simula."

"Isipin na mayroon kang klase ng Mandirigma at isang paraan na tumutukoy kung alin sa dalawang mandirigma ang mas malakas. Ganito ang hitsura nito:"

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 at ArcherWarrior parehong nagmamana ng Warrior. ."

"Ito ay maliit na simplistic, ngunit para sa isang halimbawa, ito ay gagawin."

"OK."

"Ngayon ipagpalagay na nagpasya kang gumawa ng katulad na paraan para sa sitwasyon kung saan maraming mandirigma ang sumali sa labanan."

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!

"Ngunit dito ay nakatagpo ka ng isang error sa compilation at nalilito kung ano ang maaaring mali."

"Ang bagay ay ang MagicWarrior ay nagmamana ng Warrior , at ang MagicWarrior object ay maaaring ipasa sa fight(Warrior, Warrior) method."

"Pero ang List<MagicWarior> ay hindi namamana ng List<Warrior> . Kaya, hindi ka makakapasa doon!"

"Anong ibig mong sabihin na hindi ito nagmamana?"

"Ibig kong sabihin ito: ang isa ay isang Listahan at ang isa ay isang Listahan, ngunit mayroon silang mga uri ng mga parameter."

"Tama ka. Kahit papaano hindi ko iyon napansin agad. So, may solusyon na ba sa problemang ito?"

"Oo. Kailangan mong gumamit ng mas kumplikadong istraktura. Ganito ang hitsura nito:"

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 …
 }
}

Ang bahaging «? extends Warrior» ay nangangahulugang «anumang uri na magmamana ng Warrior»"

"Sa madaling salita, maaari ka na ngayong pumasa sa isang Listahan<MagicWarrior> at isang Listahan<ArcherWarrior>, at lahat ay gagana."

"Napakahusay. Ang mas kaunting mga problema, mas mabuti."

"Ganun din ang nararamdaman ko."

"Ngunit paano kung hindi ko kailangan ng isang bagay na nagmamana ng Warrior? Paano kung gusto kong maipasa ang anumang Listahan na may anumang uri ng parameter sa pamamaraan? Pinapayagan ba iyon?"

"Oo, may dalawang anyo ng notasyon para gawin iyon:"

List<? extends Object>

List<?>

"Pareho silang ibig sabihin, kaya kadalasang ginagamit ang pangalawang bersyon."

"Yan lamang para sa araw na ito."

"Salamat, Ellie. Marami talaga akong natutunan ngayon."