Generics: Klase

"Hi! Itutuloy ko na ang lesson ni Ellie sa generics. Ready to listen?"

"Oo."

"Kung ganoon ay magsimula na tayo."

"Ang unang bagay na kailangan mong malaman ay ang mga pamamaraan ng isang klase ay maaari ding magkaroon ng sarili nilang mga parameter ng uri."

"Alam ko."

"Hindi, ang ibig kong sabihin ay ang kanilang sariling mga parameter ng uri: "

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
}

"Ang mga uri ng parameter na ito ay partikular na tumutukoy sa mga pamamaraan. Ang klase ay walang mga parameter. Maaari mo ring ideklara ang mga pamamaraang ito na static at tawagan ang mga ito nang walang object."

"Nakikita ko. Ang punto ng mga parameter ng uri sa mga pamamaraan ay kapareho ng para sa mga klase?"

"Oo. Pero may bago."

"Tulad ng alam mo na, maaari kang gumamit ng wildcard sa uri ng deklarasyon. Pagkatapos ay isipin ang sumusunod na sitwasyon:"

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

"Ngunit paano kung gusto naming magdagdag ng bagong item sa koleksyon:"

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

"Ang problema ay na sa pangkalahatang kaso ang doSomething method ay maaaring maipasa sa isang Listahan na ang mga elemento ay hindi MyClass object, ngunit sa halip ay object ng anumang subclass ng MyClass. Ngunit hindi ka maaaring magdagdag ng MyClass object sa naturang listahan!"

"Ah. So, anong pwedeng gawin diyan?"

"Wala. Sa sitwasyong ito, wala kang magagawa. Ngunit nagbigay ito ng pag-iisip sa mga tagalikha ng Java. At nakabuo sila ng bagong keyword: super ."

"Halos pareho ang hitsura ng syntax:"

List<? super MyClass> list

Ngunit mayroong isang mahalagang pagkakaiba sa pagitan ng mga extend at super.

"«? extends T» ay nangangahulugan na ang klase ay dapat na isang inapo ng T."

"«? super T» ay nangangahulugan na ang klase ay dapat na ninuno ng T."

"Holy moly. So saan ito ginagamit?"

Ang "«? super T» ay ginagamit kapag ang isang pamamaraan ay nagsasangkot ng pagdaragdag sa isang koleksyon ng mga bagay na T. Sa kasong ito, ito ay maaaring isang koleksyon ng mga bagay na T o anumang ninuno ng T."

"Ah. Maaaring italaga ang AT object sa isang reference variable na ang uri ay alinman sa mga ninuno ni T"

"Sa totoo lang, hindi masyadong madalas ang approach na ito. Higit pa rito, may pagkukulang ito. Halimbawa:"

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

"Ngayon ang unang halimbawa ay hindi gumagana."

"Dahil ang listahan ay maaaring maging isang Listahan<Object> (Object ay ang pinakamataas na superclass ng MyClass), mahalagang sinusulat namin ang sumusunod na di-wastong code:"

List<Object> list; 

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

"I see. Thanks for the interesting lesson."

"Walang anuman."