Paano gumawa ng mga anotasyon

"Ngayon, gumawa at gumamit tayo ng ilang anotasyon."

"Halimbawa, sabihin nating nagsusulat kami ng isang game engine. Ang aming laro ay may maraming mga character na nabibilang sa tatlong kategorya: mga duwende, mga guwardiya ng palasyo, at mga kontrabida."

"Habang binuo ang laro, maaaring magdagdag ng mga bagong character, at babaguhin nito ang balanse ng laro. Kaya, magiging napakaginhawang italaga ang bawat 'class ng character' ng sarili nitong anotasyon na naglalarawan sa mga pisikal na katangian nito."

"Ang paggawa nito ay magiging napakadali upang gayahin ang mga labanan sa pagitan ng iba't ibang mga character at/o mabilis na pagkalkula ng balanse ng laro."

"I agree. That's a good idea."

"Gumawa tayo ng @Person annotation na mag-iimbak ng buhay, lakas, at magic, pati na rin ang attack at defense parameters. Ganito ang hitsura ng anotasyon:"

@interface Person
{
 String name() default "";
 int live();
 int strength();
 int magic() default 0;
 int attack() default 0;
 int defense();
}

"At, bilang halimbawa, ganito ang magiging hitsura ng paglalarawan ng isang forest elf mage:"

@Person(live = 100, strength = 10, magic = 5, attack = 20, defense = 20)
class Elf
{
 …
}

"At narito ang magiging hitsura ng paglalarawan ng pangunahing kontrabida:"

@Person(live = 1000, strength = 150, magic = 250, attack = 99, defense = 99)
class EvilMaster
{
 …
}

"I see. It reminds me a little of marker interfaces."

"Oo. Maliban, una, hindi mo kailangang magmana. At pangalawa, maaari kang mag-imbak ng karagdagang impormasyon sa mga anotasyon."

"May ilan pang anotasyon na ginagamit upang markahan ang mga anotasyon. Narito ang mga ito: "

"Ang @Retention annotation ay nagsasaad kung saan makikita ang aming anotasyon: sa source code lang, kahit pagkatapos ng compilation, o kahit na sa run time."

"Ang @Target annotation ay nagpapahiwatig kung ano ang partikular na maaaring markahan gamit ang anotasyon: mga klase, field, pamamaraan, parameter ng pamamaraan, atbp."

"Kung gusto naming mailapat ang aming annotation sa mga klase na nagmamana ng annotated na klase at hindi lang sa annotated na klase mismo, kailangan namin itong i-annotate gamit ang @Inherited."

"Ito ang magiging hitsura ng aming @Person. annotation."

@Target(value = ElementType.TYPE)
@Retention(value = RetentionPolicy.RUNTIME)
@interface Person
{
 String name() default "";
 int live();
 int strength();
 int magic() default 0;
 int attack() default 0;
 int defence();
}

"Iyon ay napaka-interesante, salamat, Rishi."

Ngunit paano ka gagana sa mga anotasyong ito sa programa? Paano mo ginagamit ang mga ito? Paano mo nababasa ang kanilang mga halaga?"

"Ito ay karaniwang ginagawa gamit ang Reflection ."

"Narito kung paano namin matutukoy kung aling karakter ang mas malakas:"

public boolean fight(Class first, Class second)
{
 if (!first.isAnnotationPresent(Person.class))
  throw new RuntimeException("first param is not game person");
 if (!second.isAnnotationPresent(Person.class))
  throw new RuntimeException("second param is not game person");

 Person firstPerson = (Person) first.getAnnotation(Person.class);
 Person secondPerson = (Person) second.getAnnotation(Person.class);

 int firstAttack = firstPerson.attack() * firstPerson.strength() + firstPerson.magic();
 int firstPower = firstPerson.live() * firstPerson.defence() * firstAttack;

 int secondAttack = secondPerson.attack() * secondPerson.strength() + secondPerson.magic();
 int secondPower = secondPerson.live() * secondPerson.defence() * secondAttack;

 return firstPower > secondPower;
}

"Narito ang mga pamamaraan na kailangan natin:"

isAnnotationPresent(Annotation.class)

getAnnotation(Annotation.class)

Annotation[] getAnnotations()

"Great. I didn't expect na ang pagkuha ng annotation ay magiging sobrang simple."

"Uh huh." Tawagan lang ang paraan ng getAnnotation ng object, na ipinapasa ang nais na uri ng anotasyon."

"Iyon lang para sa araw na ito."

"Salamat, Rishi. This was a very interesting lesson. Now I don't fear annotation like I do water."