एनोटेशन कैसे बनाएं

"अब कुछ एनोटेशन बनाते हैं और उनका उपयोग करते हैं।"

"उदाहरण के लिए, मान लें कि हम एक गेम इंजन लिख रहे हैं। हमारे गेम में बहुत सारे पात्र हैं जो तीन श्रेणियों में आते हैं: कल्पित बौने, महल रक्षक और खलनायक।"

"जैसा कि खेल विकसित किया गया है, नए वर्ण जोड़े जा सकते हैं, और यह खेल संतुलन को बदल देगा। इस प्रकार, प्रत्येक 'चरित्र वर्ग' को अपनी स्वयं की व्याख्या निर्दिष्ट करना बहुत सुविधाजनक होगा जो इसकी भौतिक विशेषताओं का वर्णन करता है।"

"ऐसा करने से विभिन्न पात्रों के बीच लड़ाई को अनुकरण करना और/या गेम संतुलन की तुरंत गणना करना बहुत आसान हो जाएगा।"

"मैं सहमत हूँ। यह एक अच्छा विचार है।"

"आइए एक @Person एनोटेशन बनाएं जो जीवन, शक्ति और जादू के साथ-साथ हमले और रक्षा मापदंडों को संग्रहीत करेगा। यहां बताया गया है कि एनोटेशन कैसा दिखता है:"

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

"और, एक उदाहरण के रूप में, यहाँ एक वन योगिनी दाना का वर्णन कैसा दिखेगा:"

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

"और यहां बताया गया है कि मुख्य खलनायक का विवरण कैसा दिखेगा:"

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

"मैं देख रहा हूँ। यह मुझे थोड़ा सा मार्कर इंटरफेस याद दिलाता है।"

"हां। पहले को छोड़कर, आपको कुछ भी विरासत में नहीं मिलना है। और दूसरा, आप एनोटेशन में अतिरिक्त जानकारी स्टोर कर सकते हैं।"

" एनोटेशन चिह्नित करने के लिए कुछ और एनोटेशन का उपयोग किया जाता है। यहां वे हैं: "

"@Retention एनोटेशन इंगित करता है कि हमारा एनोटेशन कहाँ दिखाई देगा: केवल स्रोत कोड में, संकलन के बाद भी, या रन टाइम पर भी।"

"@Target एनोटेशन इंगित करता है कि एनोटेशन का उपयोग करके विशेष रूप से क्या चिह्नित किया जा सकता है: कक्षाएं, फ़ील्ड, विधियां, विधि पैरामीटर इत्यादि।"

"यदि हम चाहते हैं कि हमारा एनोटेशन उन वर्गों पर लागू हो जो एनोटेट क्लास को इनहेरिट करते हैं, न कि एनोटेट क्लास को ही, तो हमें इसे @Inherited के साथ एनोटेट करने की आवश्यकता है।"

"हमारा @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();
}

"यह बहुत दिलचस्प था, धन्यवाद, ऋषि।"

लेकिन आप प्रोग्राम में इन एनोटेशन के साथ कैसे काम करते हैं? आप उनका कैसे उपयोग करते हैं? आप उनके मूल्यों को कैसे पढ़ते हैं?"

"यह आमतौर पर प्रतिबिंब का उपयोग करके किया जाता है ।"

"यहां बताया गया है कि हम कैसे निर्धारित करेंगे कि कौन सा चरित्र अधिक मजबूत है:"

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

"यहाँ वे विधियाँ हैं जिनकी हमें आवश्यकता है:"

isAnnotationPresent(Annotation.class)

getAnnotation(Annotation.class)

Annotation[] getAnnotations()

"बहुत बढ़िया। मुझे उम्मीद नहीं थी कि एनोटेशन प्राप्त करना इतना आसान होगा।"

"अहां।" वांछित एनोटेशन प्रकार में गुजरने के लिए बस ऑब्जेक्ट की getAnnotation विधि को कॉल करें।"

"आज के लिए इतना ही।"

"धन्यवाद, ऋषि। यह एक बहुत ही दिलचस्प सबक था। अब मैं एनोटेशन से नहीं डरता, जैसे मैं पानी से करता हूँ।"