జావాలో ఉల్లేఖనాలు

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

public class DocumentsFolder {
   private List documents;

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

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