ఉల్లేఖనాల యొక్క ప్రధాన ప్రయోజనం ఇప్పటికే JDKలో ఉన్న ప్రామాణిక వాటిని ఉపయోగించడం ద్వారా రాదు. అదే సమయంలో, మీ స్వంత ఉల్లేఖనాన్ని సృష్టించడం చాలా అరుదుగా ఉంటుంది. కానీ మేము ఒక పెద్ద వ్యవస్థను అభివృద్ధి చేస్తున్నట్లయితే లేదా ప్రత్యేక లైబ్రరీని రూపొందిస్తున్నట్లయితే, నిర్మాణ స్థాయిలో, మా స్వంత ఉల్లేఖనాన్ని అమలు చేయడం వలన ఖచ్చితంగా డివిడెండ్ లభిస్తుంది.
ఉల్లేఖనాన్ని రూపొందించడానికి ప్రయత్నిద్దాం.
దీన్ని చేయడానికి, ఫైల్‌ను సృష్టించండి, కానీ క్లాస్ లేదా ఇంటర్‌ఫేస్ రాయడానికి బదులుగా , @interface అని వ్రాయండి . ఇది మా ఉల్లేఖన కోసం ఫైల్ అవుతుంది. ఉల్లేఖనం యొక్క అంతర్గత నిర్మాణం ఇంటర్‌ఫేస్ మాదిరిగానే ఉంటుంది.
public @interface Sum {
int sum() default 0;
}@interface ఇది ఉల్లేఖనమని సూచిస్తుంది, పరామితి నిర్దిష్ట డిఫాల్ట్ విలువను కలిగి ఉంటుందని
డిఫాల్ట్ చెబుతుంది.
టా-డా! మేము ఉల్లేఖనాన్ని సృష్టించాము! సిద్ధాంతపరంగా మనం దీన్ని ఇప్పటికే ఉపయోగించుకోవచ్చు, కానీ ముందుగా దాన్ని కాన్ఫిగర్ చేయడం మంచిది.
కాన్ఫిగరేషన్ లేకుండా, మా ఉల్లేఖనాన్ని దేనికైనా (తరగతులు, పద్ధతులు, గుణాలు మొదలైనవి) వర్తింపజేయవచ్చు, కాబట్టి ఈ సమయంలో దీన్ని ఉపయోగించడం చాలా తక్కువ అర్ధమే. వింతగా అనిపించినా, మన ఉల్లేఖనాన్ని ఇతర ఉల్లేఖనాలతో ఉల్లేఖించాల్సిన అవసరం ఉంది!
@Target తో ప్రారంభిద్దాం .
@Target ఉల్లేఖనం (జావా 1.5 నుండి సంబంధితమైనది) ఉల్లేఖనాన్ని వర్తింపజేయగల సామర్థ్యాన్ని పరిమితం చేస్తుంది . వినియోగాన్ని నిర్దిష్ట స్థాయికి పరిమితం చేయడానికి, మేము దానిని ఏ రకాలకు వర్తింపజేయవచ్చో సూచించడానికి @Target ఉల్లేఖనానికి ఆర్గ్యుమెంట్‌ని పంపాలి . సాధారణంగా ఉపయోగించే కొన్ని రకాలు ఇక్కడ ఉన్నాయి:
| @Target(ElementType.PACKAGE) | ప్యాకేజీల కోసం |
| @Target(ElementType.TYPE) | తరగతులకు |
| @టార్గెట్(ElementType.CONSTRUCTOR) | కన్స్ట్రక్టర్ల కోసం |
| @టార్గెట్(ElementType.METHOD) | పద్ధతుల కోసం |
| @టార్గెట్(ElementType.FIELD) | తరగతిలోని గుణాలు (వేరియబుల్స్) కోసం |
| @టార్గెట్(ElementType.PARAMATER) | పద్ధతి పారామితుల కోసం |
| @టార్గెట్(ఎలిమెంట్ టైప్.LOCAL_VARIABLE) | స్థానిక వేరియబుల్స్ కోసం |
మీకు అనేక రకాల ఉల్లేఖన అవసరమైతే, మీరు అనేక ఆర్గ్యుమెంట్‌లను శ్రేణిగా పంపవచ్చు:
@Target({ ElementType.PARAMETER, ElementType.LOCAL_VARIABLE })కాన్ఫిగరేషన్ యొక్క తదుపరి ముఖ్యమైన భాగం @Retention ఉల్లేఖనం.
ఈ ఉల్లేఖనం కోడ్ జీవిత చక్రంలోని భాగాలను సూచిస్తుంది, దీనిలో మా ఉల్లేఖన అందుబాటులో ఉంటుంది:
| RetentionPolicy.SOURCE | SOURCE నిలుపుదల విధానంతో గుర్తించబడిన ఉల్లేఖనాలు రన్ సమయంలో విస్మరించబడతాయి. |
| నిలుపుదల విధానం.CLASS | CLASS నిలుపుదల విధానంతో గుర్తించబడిన ఉల్లేఖనాలు .class ఫైల్‌కి వ్రాయబడ్డాయి , కానీ అమలు సమయంలో తీసివేయబడతాయి. |
| నిలుపుదల విధానం.RUNTIME | RUNTIME నిలుపుదల విధానంతో గుర్తు పెట్టబడిన ఉల్లేఖనాలు రన్ టైమ్‌లో కొనసాగుతాయి మరియు రన్ టైమ్‌లో మా ప్రోగ్రామ్‌లో యాక్సెస్ చేయవచ్చు. |
కాన్ఫిగరేషన్ కోసం మీరు ఉపయోగించగల మరికొన్ని ఉల్లేఖనాలు ఉన్నాయి:
| ఉల్లేఖనం | విలువ |
|---|---|
| @వారసత్వంగా | ఉత్పన్నమైన తరగతి ఉల్లేఖన యొక్క పేరెంట్ క్లాస్ యొక్క అమలును వారసత్వంగా పొందుతుందని సూచిస్తుంది. |
| @డాక్యుమెంట్ చేయబడింది | ఉత్పత్తి చేయబడిన Javadoc డాక్యుమెంటేషన్‌లో ఉల్లేఖన చేర్చబడుతుందని ఇది సూచిస్తుంది. |
ఇప్పుడు మన స్వంత ఉల్లేఖనాన్ని రూపొందించడానికి ప్రయత్నిద్దాం.
మేము తరగతులు మరియు పద్ధతుల కోసం ఉల్లేఖనాన్ని సృష్టిస్తాము మరియు కోడ్ యొక్క రచయిత మరియు సంస్కరణకు సంబంధించిన సమాచారాన్ని కలిగి ఉంటాము:
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Info {
String author() default "Author";
String version() default "0.0";
}మేము మా ఉల్లేఖనాన్ని పద్ధతులు మరియు తరగతులకు వర్తింపజేయవచ్చు. మా ఉల్లేఖన మెటాడేటా రన్ సమయంలో అందుబాటులో ఉంటుంది. మా ఉల్లేఖన పారామితులకు శ్రద్ధ వహించండి: మేము రెండు ఆర్గ్యుమెంట్‌లను (రచయిత మరియు సంస్కరణ) అందించగలము లేదా మేము వాటిని వదిలివేయవచ్చు. మేము వాటిని వదిలివేస్తే, పేర్కొన్న డిఫాల్ట్ విలువలు ( డిఫాల్ట్ "రచయిత" మరియు డిఫాల్ట్ "0.0" ) ఉపయోగించబడుతుంది.
మేము పారామితుల కోసం డిఫాల్ట్ విలువను పేర్కొనవలసిన అవసరం లేదని గమనించాలి. ఈ సందర్భంలో, పరామితి తప్పనిసరి అవుతుంది.
ఆర్గ్యుమెంట్‌లను పాస్ చేస్తున్నప్పుడు, సంజ్ఞామానం విలువ = "విలువ" ఉపయోగించి సంబంధిత పరామితిని మనం తప్పనిసరిగా పేర్కొనాలి . ఉల్లేఖనానికి ఒకే పరామితి ఉన్నప్పటికీ, పరామితి ఎల్లప్పుడూ స్పష్టంగా పేరు పెట్టబడాలి.
మా ఉల్లేఖనాన్ని కొన్ని తరగతులకు వర్తింపజేద్దాం:
@Info
public class MyClass1 {
@Info
public void myClassMethod() {}
}
@Info(version = "2.0")
public class MyClass2 {
@Info(author = "Anonymous")
public void myClassMethod() {}
}
@Info(author = "Anonymous", version = "2.0")
public class MyClass3 {
@Info(author = "Anonymous", version = "4.0")
public void myClassMethod() {}
}