அநாமதேய வகுப்புகள்

வணக்கம்! இன்றைய பாடத்தில், உள்ளமைக்கப்பட்ட வகுப்புகளின் தலைப்பை தொடர்ந்து ஆராய்வோம். இப்போது கடைசி குழுவிற்கான நேரம் இது: அநாமதேய உள் வகுப்புகள். எங்கள் வரைபடத்திற்கு திரும்புவோம்: கடந்த பாடத்தில் நாம் பேசிய உள்ளூர் வகுப்புகளைப் போலவே, அநாமதேய வகுப்புகளும் ஒரு வகையான உள் வகுப்புகள் ... அவை பல ஒற்றுமைகள் மற்றும் வேறுபாடுகளைக் கொண்டுள்ளன. ஆனால் முதலில், உள்ளே நுழைவோம்: அவர்கள் ஏன் "அநாமதேய" என்று அழைக்கப்படுகிறார்கள்? இதற்கு பதிலளிக்க, ஒரு எளிய உதாரணத்தைக் கவனியுங்கள். எங்களிடம் ஒரு அடிப்படை நிரல் உள்ளது என்று கற்பனை செய்து பாருங்கள், அது தொடர்ந்து இயங்குகிறது மற்றும் ஏதாவது செய்கிறது. இந்த திட்டத்திற்கான கண்காணிப்பு அமைப்பை உருவாக்க விரும்புகிறோம், இது பல தொகுதிகள் கொண்டது. ஒரு தொகுதியானது செயல்திறனின் பொதுவான குறிகாட்டிகளைக் கண்காணித்து ஒரு பதிவை பராமரிக்கும். இரண்டாவது பிழை பதிவில் பிழைகளை பதிவு செய்து பதிவு செய்யும். மூன்றாவது சந்தேகத்திற்குரிய செயல்பாட்டைக் கண்காணிக்கும்: எடுத்துக்காட்டாக, அங்கீகரிக்கப்படாத அணுகல் முயற்சிகள் மற்றும் பாதுகாப்பு தொடர்பான பிற விஷயங்கள். ஏனெனில் மூன்று தொகுதிகளும், சாராம்சத்தில், நிரலின் தொடக்கத்தில் தொடங்கி பின்னணியில் இயங்க வேண்டும்.

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");
   }
};

Oracle ஆவணம் ஒரு நல்ல பரிந்துரையை வழங்குகிறது : "உள்ளூர் வகுப்பை ஒருமுறை மட்டுமே பயன்படுத்த வேண்டும் என்றால் [அநாமதேய வகுப்புகளைப்] பயன்படுத்தவும்." ஒரு அநாமதேய வகுப்பு என்பது ஒரு முழு அளவிலான உள் வகுப்பாகும். அதன்படி, நிலையான மற்றும் தனிப்பட்ட மாறிகள் உட்பட வெளிப்புற வகுப்பின் மாறிகளுக்கு இது அணுகலைக் கொண்டுள்ளது:

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!");
   }

};

இன்று எங்கள் பாடம் முடிவுக்கு வந்துவிட்டது! ஆனால் உள்ளமைக்கப்பட்ட வகுப்புகளின் கடைசி குழுவை நாங்கள் ஆராய்ந்தாலும், இந்த தலைப்பை நாங்கள் இன்னும் முடிக்கவில்லை. உள்ளமைக்கப்பட்ட வகுப்புகளைப் பற்றி மேலும் என்ன கற்றுக்கொள்வோம்? நீங்கள் நிச்சயமாக விரைவில் கண்டுபிடிப்பீர்கள்! :)