Comment créer des annotations

"Maintenant, créons et utilisons quelques annotations."

"Par exemple, disons que nous écrivons un moteur de jeu. Notre jeu a beaucoup de personnages qui se répartissent en trois catégories : les elfes, les gardes du palais et les méchants."

"Au fur et à mesure que le jeu est développé, de nouveaux personnages peuvent être ajoutés, ce qui modifiera l'équilibre du jeu. Ainsi, il serait très pratique d'attribuer à chaque" classe de personnage "sa propre annotation décrivant ses caractéristiques physiques."

"Cela permettrait de simuler très facilement des batailles entre différents personnages et/ou de calculer rapidement l'équilibre du jeu."

"Je suis d'accord. C'est une bonne idée."

"Créons une annotation @Person qui stockera la vie, la force et la magie, ainsi que les paramètres d'attaque et de défense. Voici à quoi ressemble l'annotation :"

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

"Et, à titre d'exemple, voici à quoi ressemblerait la description d'un mage elfe de la forêt :"

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

"Et voici à quoi ressemblerait la description du méchant principal :"

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

"Je vois. Cela me rappelle un peu les interfaces de marqueur."

"Oui. Sauf que, premièrement, vous n'avez rien à hériter. Et deuxièmement, vous pouvez stocker des informations supplémentaires dans des annotations."

"Il y a quelques annotations supplémentaires utilisées pour marquer les annotations. Les voici : "

"L'annotation @Retention indique où notre annotation sera visible : uniquement dans le code source, même après compilation, ou même au moment de l'exécution."

"L'annotation @Target indique ce qui peut être spécifiquement marqué à l'aide de l'annotation : classes, champs, méthodes, paramètres de méthode, etc."

"Si nous voulons que notre annotation soit appliquée aux classes qui héritent d'une classe annotée et pas seulement à la classe annotée elle-même, nous devons l'annoter avec @Inherited."

"Voici à quoi ressemblerait notre annotation @Person .."

@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();
}

"C'était très intéressant, merci, Rishi."

Mais comment travaillez-vous avec ces annotations dans le programme ? Comment les utilisez-vous ? Comment lis-tu leurs valeurs ?"

"Cela se fait généralement à l'aide de Reflection ."

"Voici comment nous déterminerions quel personnage est le plus fort :"

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

"Voici les méthodes dont nous avons besoin :"

isAnnotationPresent(Annotation.class)

getAnnotation(Annotation.class)

Annotation[] getAnnotations()

"Génial. Je ne m'attendais pas à ce que recevoir une annotation soit aussi simple."

"Euh-huh." Appelez simplement la méthode getAnnotation de l'objet, en transmettant le type d'annotation souhaité."

"C'est tout pour aujourd'hui."

"Merci, Rishi. C'était une leçon très intéressante. Maintenant, je ne crains plus les annotations comme je le fais avec l'eau."