Anmerkungen zum Erstellen

„Jetzt erstellen und verwenden wir ein paar Anmerkungen.“

„Nehmen wir zum Beispiel an, wir schreiben eine Spiel-Engine. Unser Spiel hat viele Charaktere, die in drei Kategorien fallen: Elfen, Palastwächter und Bösewichte.“

„Während das Spiel entwickelt wird, können neue Charaktere hinzugefügt werden, was die Spielbalance verändern wird. Daher wäre es sehr praktisch, jeder ‚Charakterklasse‘ eine eigene Anmerkung zuzuweisen, die ihre physischen Eigenschaften beschreibt.“

„Dies würde es sehr einfach machen, Kämpfe zwischen verschiedenen Charakteren zu simulieren und/oder die Spielbalance schnell zu berechnen.“

„Ich stimme zu. Das ist eine gute Idee.“

„Lassen Sie uns eine @Person- Annotation erstellen, die Leben, Stärke und Magie sowie Angriffs- und Verteidigungsparameter speichert. So sieht die Annotation aus:“

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

„Und so würde beispielsweise die Beschreibung eines Waldelfenmagiers aussehen:“

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

„Und so würde die Beschreibung des Hauptschurken aussehen:“

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

„Ich verstehe. Es erinnert mich ein wenig an Marker-Schnittstellen.“

„Ja. Außer erstens müssen Sie nichts erben. Und zweitens können Sie zusätzliche Informationen in Anmerkungen speichern.“

„Es gibt noch ein paar weitere Anmerkungen, die zum Markieren von Anmerkungen verwendet werden. Hier sind sie: “

„Die Annotation @Retention gibt an, wo unsere Annotation sichtbar sein wird: nur im Quellcode, auch nach der Kompilierung oder sogar zur Laufzeit.“

„Die @Target-Annotation gibt an, was konkret mit der Annotation markiert werden kann: Klassen, Felder, Methoden, Methodenparameter usw.“

„Wenn wir möchten, dass unsere Annotation auf Klassen angewendet wird, die eine annotierte Klasse erben, und nicht nur auf die annotierte Klasse selbst, dann müssen wir sie mit @Inherited annotieren.“

„So würde unsere @Person.- Annotation aussehen.“

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

„Das war sehr interessant, danke, Rishi.“

Aber wie arbeitet man mit diesen Anmerkungen im Programm? Wie benutzt man sie? Wie lesen Sie ihre Werte?“

„Dies erfolgt im Allgemeinen mithilfe von Reflection .“

„So würden wir feststellen, welcher Charakter stärker ist:“

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

„Hier sind die Methoden, die wir brauchen:“

isAnnotationPresent(Annotation.class)

getAnnotation(Annotation.class)

Annotation[] getAnnotations()

„Großartig. Ich hätte nicht gedacht, dass es so einfach sein würde, eine Anmerkung zu bekommen.“

„Uh-huh.“ Rufen Sie einfach die getAnnotation-Methode des Objekts auf und übergeben Sie den gewünschten Annotationstyp.

"Das war `s für heute."

„Danke, Rishi. Das war eine sehr interessante Lektion. Jetzt habe ich keine Angst mehr vor Anmerkungen wie vor Wasser.“