ఉల్లేఖనాలను ఎలా సృష్టించాలి

"ఇప్పుడు మనం కొన్ని ఉల్లేఖనాలను సృష్టించి, ఉపయోగిస్తాము."

"ఉదాహరణకు, మేము గేమ్ ఇంజిన్‌ని వ్రాస్తున్నాము అనుకుందాం. మా గేమ్‌లో చాలా పాత్రలు ఉన్నాయి, అవి దయ్యములు, ప్యాలెస్ గార్డ్‌లు మరియు విలన్‌లు అనే మూడు వర్గాలలోకి వస్తాయి."

"ఆట అభివృద్ధి చేయబడినప్పుడు, కొత్త అక్షరాలు జోడించబడవచ్చు మరియు ఇది గేమ్ బ్యాలెన్స్‌ని మారుస్తుంది. అందువల్ల, ప్రతి 'అక్షర తరగతి'కి దాని భౌతిక లక్షణాలను వివరించే దాని స్వంత ఉల్లేఖనాన్ని కేటాయించడం చాలా సౌకర్యవంతంగా ఉంటుంది."

"అలా చేయడం వలన విభిన్న పాత్రల మధ్య యుద్ధాలను అనుకరించడం మరియు/లేదా గేమ్ బ్యాలెన్స్‌ను త్వరగా లెక్కించడం చాలా సులభం అవుతుంది."

"నేను అంగీకరిస్తున్నాను. అది మంచి ఆలోచన."

" జీవితం, బలం మరియు మాయాజాలంతో పాటు దాడి మరియు రక్షణ పారామితులను నిల్వ చేసే @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
{
 …
}

"నేను చూస్తున్నాను. ఇది నాకు మార్కర్ ఇంటర్‌ఫేస్‌లను కొద్దిగా గుర్తు చేస్తుంది."

"అవును. తప్ప, మొదట, మీరు ఏదైనా వారసత్వంగా పొందవలసిన అవసరం లేదు. మరియు రెండవది, మీరు అదనపు సమాచారాన్ని ఉల్లేఖనాల్లో నిల్వ చేయవచ్చు."

" ఉల్లేఖనాలను గుర్తించడానికి మరికొన్ని ఉల్లేఖనాలు ఉపయోగించబడ్డాయి. అవి ఇక్కడ ఉన్నాయి: "

"@నిలుపుదల ఉల్లేఖనం మా ఉల్లేఖన ఎక్కడ కనిపిస్తుంది అని సూచిస్తుంది: కేవలం సోర్స్ కోడ్‌లో, సంకలనం తర్వాత కూడా లేదా రన్ సమయంలో కూడా."

"@టార్గెట్ ఉల్లేఖనం ఉల్లేఖనాన్ని ఉపయోగించి ప్రత్యేకంగా ఏమి గుర్తించబడుతుందో సూచిస్తుంది: తరగతులు, ఫీల్డ్‌లు, పద్ధతులు, పద్ధతి పారామితులు మొదలైనవి."

"మా ఉల్లేఖనాన్ని ఉల్లేఖన తరగతికి మాత్రమే కాకుండా, ఉల్లేఖన తరగతిని వారసత్వంగా పొందే తరగతులకు వర్తింపజేయాలనుకుంటే, మేము దానిని @Inheritedతో ఉల్లేఖించాలి."

"ఇది మా @వ్యక్తి. ఉల్లేఖనం ఇలా ఉంటుంది."

@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 పద్ధతికి కాల్ చేయండి, కావలసిన ఉల్లేఖన రకంలో పాస్ చేయండి."

"ఈరోజుకి అంతే."

"ధన్యవాదాలు, రిషీ. ఇది చాలా ఆసక్తికరమైన పాఠం. ఇప్పుడు నేను నీళ్లలాగా వ్యాఖ్యానాలకు భయపడను."