అనామక తరగతులు

హాయ్! నేటి పాఠంలో, మేము సమూహ తరగతుల అంశాన్ని పరిశీలించడం కొనసాగిస్తాము. ఇప్పుడు చివరి సమూహం కోసం సమయం వచ్చింది: అనామక అంతర్గత తరగతులు. మన రేఖాచిత్రానికి తిరిగి వెళ్దాం: గత పాఠంలో మనం మాట్లాడుకున్న స్థానిక తరగతుల మాదిరిగానే, అనామక తరగతులు ఒక రకమైన అంతర్గత తరగతి... వాటికి కూడా అనేక సారూప్యతలు మరియు తేడాలు ఉన్నాయి. అయితే ముందుగా, డైవ్ చేద్దాం: వాటిని సరిగ్గా "అనామక" అని ఎందుకు పిలుస్తారు? దీనికి సమాధానం ఇవ్వడానికి, ఒక సాధారణ ఉదాహరణను పరిగణించండి. మన దగ్గర ఒక ప్రాథమిక ప్రోగ్రామ్ ఉందని ఊహించుకోండి, అది నిరంతరం రన్ అవుతూ మరియు ఏదో చేస్తూ ఉంటుంది. మేము అనేక మాడ్యూల్స్‌తో రూపొందించబడిన ఈ ప్రోగ్రామ్ కోసం మానిటరింగ్ సిస్టమ్‌ను రూపొందించాలనుకుంటున్నాము. ఒక మాడ్యూల్ పనితీరు యొక్క సాధారణ సూచికలను ట్రాక్ చేస్తుంది మరియు లాగ్‌ను నిర్వహిస్తుంది. రెండవది ఎర్రర్ లాగ్‌లో లోపాలను నమోదు చేస్తుంది మరియు రికార్డ్ చేస్తుంది. మూడవది అనుమానాస్పద కార్యాచరణను ట్రాక్ చేస్తుంది: ఉదాహరణకు, అనధికారిక యాక్సెస్ ప్రయత్నాలు మరియు ఇతర భద్రతా సంబంధిత విషయాలు. ఎందుకంటే మూడు మాడ్యూల్స్, సారాంశంలో, ప్రోగ్రామ్ ప్రారంభంలో ప్రారంభించి, నేపథ్యంలో అమలు చేయాలి,

public interface MonitoringSystem {
  
   public void startMonitoring();
}

3 కాంక్రీట్ తరగతులు దీన్ని అమలు చేస్తాయి:

public class GeneralIndicatorMonitoringModule implements MonitoringSystem {
   
@Override
   public void startMonitoring() {
       System.out.println("Starting to monitor general indicators!");
   }
}


public class ErrorMonitoringModule implements MonitoringSystem {

   @Override
   public void startMonitoring() {
       System.out.println("Starting to monitor errors!");
   }
}


public class SecurityModule implements MonitoringSystem {

   @Override
   public void startMonitoring() {
       System.out.println("Starting to monitor security!");
   }
}

ప్రతిదీ క్రమంలో ఉన్నట్లు అనిపిస్తుంది. మేము అనేక మాడ్యూల్స్‌తో రూపొందించబడిన అందమైన పొందికైన వ్యవస్థను కలిగి ఉన్నాము. వాటిలో ప్రతి దాని స్వంత ప్రవర్తన ఉంది. మనకు కొత్త మాడ్యూల్స్ అవసరమైతే, మేము వాటిని జోడించవచ్చు, ఎందుకంటే మేము అమలు చేయడానికి చాలా సులభమైన ఇంటర్ఫేస్ను కలిగి ఉన్నాము. అయితే మన మానిటరింగ్ సిస్టమ్ ఎలా పని చేస్తుందో ఆలోచిద్దాం. ప్రాథమికంగా, మనం కేవలం 3 ఆబ్జెక్ట్‌లను సృష్టించాలి - GeneralIndicatorMonitoringModule, ErrorMonitoringModule, SecurityModule- మరియు startMonitoring()వాటిలో ప్రతిదానిపై పద్ధతిని కాల్ చేయండి. అంటే, మనం చేయాల్సిందల్లా 3 ఆబ్జెక్ట్‌లను సృష్టించడం మరియు వాటిపై 1 పద్ధతిని కాల్ చేయడం.

public class Main {

   public static void main(String[] args) {

       GeneralIndicatorMonitoringModule generalModule = new GeneralIndicatorMonitoringModule();
       ErrorMonitoringModule errorModule = new ErrorMonitoringModule();
       SecurityModule securityModule = new SecurityModule();

       generalModule.startMonitoring();
       errorModule.startMonitoring();
       securityModule.startMonitoring();
   }
}

కన్సోల్ అవుట్‌పుట్:

Starting to monitor general indicators! 
Starting to monitor errors! 
Starting to monitor security!

మరియు అటువంటి చిన్న పనితో, మేము మొత్తం సిస్టమ్‌ను వ్రాసాము: 3 తరగతులు మరియు ఒక ఇంటర్‌ఫేస్! మరియు ఇవన్నీ కోడ్ యొక్క 6 లైన్లను సాధించడానికి. మరోవైపు, మా ఎంపికలు ఏమిటి? సరే, మేము ఈ "వన్-టైమ్" తరగతులను వ్రాయడం చాలా బాగుంది కాదు. కానీ మనం దీన్ని ఎలా పరిష్కరించగలం? ఇక్కడ అనామక అంతర్గత తరగతులు మన రక్షణకు వస్తాయి! మా విషయంలో వారు ఎలా కనిపిస్తారో ఇక్కడ ఉంది:

public class Main {

   public static void main(String[] args) {

       MonitoringSystem generalModule = new MonitoringSystem() {
           @Override
           public void startMonitoring() {
               System.out.println("Starting to monitor general indicators!");
           }
       };

       

MonitoringSystem errorModule = new MonitoringSystem() {
           @Override
           public void startMonitoring() {
               System.out.println("Starting to monitor errors!");
           }
       };

       MonitoringSystem securityModule = new MonitoringSystem() {
           @Override
           public void startMonitoring() {
               System.out.println("Starting to monitor security!");
           }
       };

       generalModule.startMonitoring();
       errorModule.startMonitoring();
       securityModule.startMonitoring();
   }
}

ఏం జరుగుతుందో తెలుసుకుందాం! మేము ఇంటర్‌ఫేస్ ఆబ్జెక్ట్‌ని సృష్టిస్తున్నట్లు కనిపిస్తోంది:

MonitoringSystem generalModule = new MonitoringSystem() {
   
@Override
   public void startMonitoring() {
       System.out.println("Starting to monitor general indicators!");
   }
};

కానీ మనం ఇంటర్‌ఫేస్ ఆబ్జెక్ట్‌లను సృష్టించలేమని మనకు చాలా కాలంగా తెలుసు! మరియు అది - ఇది అసాధ్యం. నిజానికి మనం చేస్తున్నది అది కాదు. మేము వ్రాసేటప్పుడు:

MonitoringSystem generalModule = new MonitoringSystem() {
   
};

జావా మెషీన్‌లో కిందివి జరుగుతాయి:

1. ఇంటర్‌ఫేస్‌ను అమలు చేసే పేరులేని జావా క్లాస్ సృష్టించబడింది MonitoringSystem.
2. కంపైలర్ అటువంటి తరగతిని చూసినప్పుడు, మీరు MonitoringSystemఇంటర్ఫేస్ యొక్క అన్ని పద్ధతులను అమలు చేయవలసి ఉంటుంది (మేము దీన్ని 3 సార్లు చేసాము).
3. ఈ తరగతి యొక్క ఒక వస్తువు సృష్టించబడింది. కోడ్‌పై శ్రద్ధ వహించండి:

MonitoringSystem generalModule = new MonitoringSystem() {
   
};

చివర సెమికోలన్ ఉంది! ఇది ఒక కారణం కోసం అక్కడ ఉంది. మేము ఏకకాలంలో తరగతిని (కర్లీ బ్రేస్‌లను ఉపయోగించి) ప్రకటిస్తాము మరియు దాని యొక్క ఉదాహరణను (ఉపయోగించి ();) సృష్టిస్తాము. మా మూడు వస్తువులలో ప్రతి ఒక్కటి startMonitoring()దాని స్వంత మార్గంలో పద్ధతిని భర్తీ చేస్తుంది. చివరగా, మేము వాటిలో ప్రతి ఒక్కదానిపై ఈ పద్ధతిని పిలుస్తాము:

generalModule.startMonitoring();
errorModule.startMonitoring();
securityModule.startMonitoring();

కన్సోల్ అవుట్‌పుట్:

Starting to monitor general indicators! 
Starting to monitor errors! 
Starting to monitor security!

అంతే! మేము మా లక్ష్యాన్ని సాధించాము: మేము మూడు MonitoringSystemవస్తువులను సృష్టించాము, మూడు విభిన్న మార్గాల్లో ఒక పద్ధతిని అధిగమించాము మరియు దానిని మూడుసార్లు పిలిచాము. మూడు మాడ్యూల్స్ విజయవంతంగా పిలవబడ్డాయి మరియు అమలులో ఉన్నాయి. అదే సమయంలో, మా ప్రోగ్రామ్ యొక్క నిర్మాణం చాలా సరళంగా మారింది! అన్నింటికంటే, ఇప్పుడు ప్రోగ్రామ్ నుండి GeneralIndicatorMonitoringModule, ErrorMonitoringModule, మరియు SecurityModuleతరగతులు పూర్తిగా తీసివేయబడతాయి! మాకు అవి అవసరం లేదు — అవి లేకుండా మేము గొప్ప పని చేసాము. మా ప్రతి అనామక తరగతికి కొన్ని విభిన్న ప్రవర్తన అవసరమైతే, ఉదా ఇతరులకు లేని దాని స్వంత నిర్దిష్ట పద్ధతులు, మేము వాటిని సులభంగా జోడించవచ్చు:

MonitoringSystem generalModule = new MonitoringSystem() {
  
   @Override
   public void startMonitoring() {
       System.out.println("Starting to monitor general indicators!");
   }
  
   public void someSpecificMethod() {

       System.out.println("Specific method only for the first module");
   }
};

ఒరాకిల్ డాక్యుమెంటేషన్ మంచి సిఫార్సును అందిస్తుంది : "మీరు స్థానిక తరగతిని ఒక్కసారి మాత్రమే ఉపయోగించాల్సి వస్తే [అనామక తరగతులు] ఉపయోగించండి." అనామక తరగతి అనేది పూర్తి స్థాయి అంతర్గత తరగతి. దీని ప్రకారం, ఇది స్టాటిక్ మరియు ప్రైవేట్ వేరియబుల్స్‌తో సహా బాహ్య తరగతి యొక్క వేరియబుల్స్‌కు ప్రాప్యతను కలిగి ఉంది:

public class Main {

   private static int currentErrorCount = 23;

   public static void main(String[] args) {

       MonitoringSystem errorModule = new MonitoringSystem() {
          
           @Override
           public void startMonitoring() {
               System.out.println("Starting to monitor errors!");
           }

           public int getCurrentErrorCount() {

               return currentErrorCount;
           }
       };
   }
}

వారు స్థానిక తరగతులతో ఉమ్మడిగా ఏదో కలిగి ఉన్నారు: అవి ప్రకటించబడిన పద్ధతిలో మాత్రమే కనిపిస్తాయి. పై ఉదాహరణలో, పద్ధతికి errorModuleవెలుపల ఉన్న వస్తువును యాక్సెస్ చేయడానికి ఏవైనా ప్రయత్నాలు main()విఫలమవుతాయి. మరియు అనామక తరగతులు వారి "పూర్వీకుల" (లోపలి తరగతులు) నుండి వారసత్వంగా పొందే మరో ముఖ్యమైన పరిమితి ఉంది: ఒక అనామక తరగతి స్టాటిక్ వేరియబుల్స్ మరియు పద్ధతులను కలిగి ఉండదు . పై ఉదాహరణలో, మేము getCurrentErrorCount()పద్ధతిని స్థిరంగా చేయడానికి ప్రయత్నిస్తే, కంపైలర్ లోపాన్ని సృష్టిస్తుంది:

// Error! Inner classes cannot have static declarations
public static int getCurrentErrorCount() {

   return currentErrorCount;
}

మేము స్టాటిక్ వేరియబుల్‌ని ప్రకటించడానికి ప్రయత్నిస్తే అదే ఫలితాన్ని పొందుతాము:

MonitoringSystem errorModule = new MonitoringSystem() {

   // Error! Inner classes cannot have static declarations!
   static int staticInt = 10;

   @Override
   public void startMonitoring() {
       System.out.println("Starting to monitor errors!");
   }

};

మరియు ఈ రోజు మా పాఠం ముగిసింది! కానీ మేము సమూహ తరగతుల చివరి సమూహాన్ని పరిశోధించినప్పటికీ, మేము ఈ అంశాన్ని ఇంకా పూర్తి చేయలేదు. సమూహ తరగతుల గురించి మనం ఇంకా ఏమి నేర్చుకుంటాము? మీరు ఖచ్చితంగా త్వరలో కనుగొంటారు! :)