2005లో, జావా 5 రాకతో, ఉల్లేఖనాలు అనే కొత్త ఎంటిటీలను మేము తెలుసుకున్నాము.

ఉల్లేఖనాలు అనేది కోడ్‌లో ప్రకటించబడే వాక్యనిర్మాణ మెటాడేటా యొక్క ప్రత్యేక రూపం. సంకలనం లేదా రన్‌టైమ్‌లో కోడ్‌ను విశ్లేషించడానికి అవి ఉపయోగించబడతాయి. మీరు ఉల్లేఖనాన్ని లేబుల్, ట్యాగ్ లేదా కంపైలర్ సూచనగా భావించవచ్చు.

మీరు బహుశా ఇంతకు ముందు ఉల్లేఖనాలను చూసి ఉండవచ్చు. ఉదాహరణకు, పేరెంట్ క్లాస్ యొక్క పద్ధతిని ఓవర్‌రైడ్ చేసినప్పుడు, మేము పద్ధతి కంటే ముందు @ఓవర్‌రైడ్ అని వ్రాస్తాము. పిల్లల తరగతిలో తల్లిదండ్రుల పద్ధతి భర్తీ చేయబడుతుందని ఈ ఉల్లేఖనం సూచిస్తుంది.

సింటాక్స్:


@Override
public int hashCode() {
      return super.hashCode();
}

ఉల్లేఖనాలు పద్ధతులకు మాత్రమే వర్తించవని నేను వెంటనే గమనించాలనుకుంటున్నాను. అవి ప్యాకేజీలు, తరగతులు, పద్ధతులు, ఫీల్డ్‌లు మరియు పారామితులతో ఉపయోగించబడతాయి.

ఉల్లేఖనాలు ఎలా పని చేస్తాయో అర్థం చేసుకోవడానికి, మొదట మార్కర్ ఇంటర్‌ఫేస్ భావనతో పరిచయం చేసుకుందాం. జావా వచ్చినప్పటి నుండి, డెవలపర్‌లకు వాటిపై నిర్దిష్ట చర్యలను చేయడానికి తరగతులను గుర్తించడానికి ఎల్లప్పుడూ ఒక మార్గం అవసరం.

Java 5కి ముందు, వారు ఇంటర్‌ఫేస్‌ని ఉపయోగించారు, అది మేము ఇంటర్‌ఫేస్‌లు చేయాలనుకుంటున్నాము. దీనికి పద్ధతులు లేవు మరియు ఒప్పందం లేదు. ఇది కేవలం తరగతిని ఏదో ఒక విధంగా ప్రత్యేకమైనదిగా గుర్తించింది.

అటువంటి ఇంటర్‌ఫేస్‌ను మార్కర్ ఇంటర్‌ఫేస్ అని పిలుస్తారు. JVM, కంపైలర్ లేదా కొన్ని లైబ్రరీ కోసం తరగతులను గుర్తించడం దీని ఉద్దేశ్యం అని మీరు పేరు నుండి ఊహించవచ్చు. సీరియలైజబుల్ వంటి కొన్ని మార్కర్ ఇంటర్‌ఫేస్‌లు మిగిలి ఉన్నాయి. ఈ మార్కర్ ఇంటర్‌ఫేస్ ఒక తరగతి యొక్క సందర్భాలను సీరియలైజ్ చేయవచ్చని సూచించడానికి అనుమతిస్తుంది.

మేము చూసినట్లుగా, ఉల్లేఖనాలను ప్రవేశపెట్టిన తర్వాత కూడా మార్కర్ ఇంటర్‌ఫేస్‌లు కొనసాగుతాయి.

ఉల్లేఖనాలు వర్సెస్ మార్కర్ ఇంటర్‌ఫేస్‌లు:


@MyAnnotation
public class MyClass {}

public class MyClass implements MarkerInterface {}

రెండు విధానాలు ఒకే లక్ష్యాన్ని కలిగి ఉన్నాయి, కానీ వాటి అమలులో స్పష్టమైన వ్యత్యాసం ఉంది. ఉదాహరణకు, తరగతి నిర్దిష్ట రకానికి చెందినదని సూచించే ఇంటర్‌ఫేస్ మరియు ఉల్లేఖనాన్ని పరిగణించండి.

మేము ఇంటర్‌ఫేస్‌ని ఉపయోగిస్తుంటే, మేము తరగతిని గుర్తు చేస్తాము. మేము దానిని తప్పుగా ఉపయోగించినట్లయితే మరియు లోపం సంభవించినట్లయితే, అప్పుడు మేము సంకలనంలో సమస్యను కనుగొంటాము మరియు ప్రోగ్రామ్ అమలు చేయబడదు.

ఉల్లేఖనాలతో, ప్రతిదీ చాలా సులభం కాదు: ఇక్కడ లోపం రన్‌టైమ్‌లో గుర్తించబడుతుంది, అంటే ప్రోగ్రామ్ ప్రారంభమవుతుంది, కానీ, ఆశ్చర్యకరంగా, అది పూర్తి కాదు.

భవిష్యత్ ఉపయోగం కోసం మేము తరగతిని గుర్తించాల్సిన అవసరం ఉన్నట్లయితే, దాని ఉదాహరణలు తప్పనిసరిగా నిర్దిష్ట పద్ధతికి పంపబడాలని గుర్తుంచుకోండి:


public class MyInteger implements Sum {}
interface Sum {};

public static void main(String[] args) throws IOException {
        increase(new MyInteger());
}
 
public static void increase(Sum count) {
        // TODO
}

మార్కర్ ఇంటర్‌ఫేస్ ఇక్కడ ఉత్తమంగా పని చేస్తుంది.

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

JDKలోని ప్రామాణిక ఉల్లేఖనాలను చూద్దాం:

ఉల్లేఖనం వివరణ ఉదాహరణ
@ఓవర్‌రైడ్ ఒక పద్ధతి సూపర్‌క్లాస్ పద్ధతిని భర్తీ చేస్తుందని లేదా అబ్‌స్ట్రాక్ట్ క్లాస్ లేదా ఇంటర్‌ఫేస్ పద్ధతిని అమలు చేస్తుందని పేర్కొంటుంది.

@Override
public int hashCode() {
        return super.hashCode();
}
@విస్మరించబడింది కోడ్‌ని విస్మరించినట్లు గుర్తు చేస్తుంది.

@Deprecated
public abstract void method();
@SuppressWarnings ఉల్లేఖన మూలకం కోసం కంపైలర్ హెచ్చరికలను నిలిపివేస్తుంది. మీరు బహుళ వర్గాల హెచ్చరికలను డిసేబుల్ చేయవలసి వస్తే, అవి తప్పనిసరిగా కర్లీ బ్రేస్‌లతో జతచేయబడాలని గుర్తుంచుకోండి, ఉదాహరణకు @SuppressWarnings({"చెక్ చేయబడలేదు", "cast"}) .

public class DocumentsFolder {
   private List documents;

   @SuppressWarnings("unchecked")
public void addDocument(String document) {
            documents.add(document);
   }
}

ఈ ఉదాహరణలో, మేము నిర్వచించిన రకం (సాధారణ రకం) లేని జాబితాకు జోడించడానికి ప్రయత్నిస్తున్నాము. కంపైలర్ దీని గురించి మనల్ని హెచ్చరిస్తుంది. ఇది చాలా ఉపయోగకరంగా ఉంటుంది, కానీ కొన్నిసార్లు చాలా "హెచ్చరికలు" ఉన్నాయి మరియు అవి ధ్వనించేవిగా ఉంటాయి. మీరు ఈ పద్ధతి ఉల్లేఖనాన్ని ఉపయోగించవచ్చు మరియు ఒక రకమైన కంపైలర్ హెచ్చరికను వాదనగా పేర్కొనవచ్చు. చాలా మార్కర్‌లు ఉన్నాయి, కాబట్టి వాటన్నింటినీ గుర్తుంచుకోవడం గురించి చింతించకండి — IDEA సాధారణంగా ఏది జోడించాలో మీకు తెలియజేస్తుంది.

బహుళ వాదనలతో మరొక ఉదాహరణ:


@SuppressWarnings({"unchecked", "deprecated"})